/* Textcoding Unicode (UTF-8, no BOM), End of Line Windows (CRLF)

bin2wav.c

		V 1.3	www.pocketmuseum.com

2011-12-05	V 1.4	Manfred NOSSWITZ
	Changed to ANSI-C e.g. strupr()
	Command line parser changed to getopt().
	Quiet mode added.
	32bit compilation with gcc (tdm64-1) 4.6.1 (WindowsXP-prof [32bit]): gcc -pedantic -m32 -o xxx xxx.c
	32bit compilation with gcc-4_5-branch revision 167585 (OpenSUSE 11.4 [32bit]): gcc -pedantic -m32 -o xxx xxx.c
	64bit compilation with gcc (tdm64-1) 4.6.1 (Windows7-prof [64bit]): gcc -pedantic -m64 -o xxx xxx.c
	64bit compilation with gcc-4_5-branch revision 167585 (OpenSUSE 11.4 [64bit]): gcc -pedantic -m64 -o xxx xxx.c
	For testing PC-1402 was available only
*/
		   
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>		/* Command line parser getopt(). */

#define ERR_OK          0
#define ERR_NOK        -1

#define TYPE_NOK        0
#define TYPE_BIN        1
#define TYPE_IMG        2

#define IDENT_UNKNOWN   0x00
#define IDENT_OLD_BAS   0x20
#define IDENT_OLD_PAS   0x21
#define IDENT_OLD_BIN   0x26
#define IDENT_NEW_BAS   0x70
#define IDENT_NEW_PAS   0x71
#define IDENT_EXT_BAS   0x72
#define IDENT_EXT_PAS   0x73
#define IDENT_NEW_BIN   0x76
#define IDENT_PC1211    0x80
#define IDENT_PC1500    0x0A
#define IDENT_PC15_BIN  0xA0
#define IDENT_PC15_BAS  0xA1

#define ORDER_STD       0
#define ORDER_INV       1

#define MODE_B22        0
#define MODE_B21        1
#define MODE_B20        2
#define MODE_B19        3
#define MODE_B17        4
#define MODE_B16        5
#define MODE_B14        6
#define MODE_B13        7

#define BASE_FREQ1      4000
#define BASE_FREQ2      2500

#define CHAR_SPACE      0x20
#define CHAR_DOT        0x2E
#define CHAR_COLON      0x3A
#define CHAR_SLASH      0x5C
#define CHAR_UNDERSCORE 0x5F

#define cLPF 129		/* Constant value for max. Length of PathFilenames */

/*                      used types  */ 
/*			char;	    */
typedef unsigned char	uchar;
/*			int;	    */
typedef unsigned int	uint;
/*			long;	    */
typedef unsigned long	ulong;

char  argP[cLPF] = "" ;
uint  Qcnt = 0 ;

typedef struct {
    FILE*  ptrFd ;
    ulong  ident ;
    ulong  count ;
    ulong  sum ;
} FileInfo ;

typedef struct {
    ulong  nb1 ;
    ulong  nb2 ;
} ModeInfo ;

static ModeInfo Mode[] = {
    { 6, 6 }, { 5, 6 }, { 5, 5 }, { 4, 5 },
    { 1, 6 }, { 1, 5 }, { 1, 3 }, { 1, 2 }
} ;

static char* bit[] = {
    "\255\255\0\0\255\255\0\0\255\255\0\0\255\255\0\0",
    "\255\0\255\0\255\0\255\0\255\0\255\0\255\0\255\0"
} ;

static ulong CodeOld[] = {
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
    0x11,0x14,0x12,0x15,0x19,0x16,0x1F,0x11,
    0x30,0x31,0x37,0x35,0x1B,0x36,0x4A,0x38,
    0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
    0x48,0x49,0x1D,0x1C,0x33,0x34,0x32,0x13,
    0x1E,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
    0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
    0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
    0x68,0x69,0x6A,0x11,0x11,0x11,0x39,0x11,
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
    0x19,0x11,0x1A,0x11,0x11,0x11,0x11,0x11,
    0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11
} ;


void CvShortToStringI (uint  value,
                       char*  ptrStr)
{
    uint  tmp ;

    /* Convert the short value into a String with msb first (INTEL) */
    tmp = value & 0xFF ;
    *ptrStr ++ = (char) tmp ;
    tmp = value >> 8 ;
    *ptrStr ++ = (char) tmp ;
    *ptrStr = 0 ;
}

void CvLongToStringI (ulong  value,
                      char*  ptrStr)
{
    ulong  tmp ;

    /* Convert the 32bit value into a String with msb first (INTEL) */
    tmp = value & 0xFF ;
    *ptrStr ++ = (char) tmp ;
    tmp = (value >> 8) & 0xFF ;
    *ptrStr ++ = (char) tmp ;
    tmp = (value >> 16) & 0xFF ;
    *ptrStr ++ = (char) tmp ;
    tmp = value >> 24 ;
    *ptrStr ++ = (char) tmp ;
    *ptrStr = 0 ;
}


/* String-change UPPER */
char *strupr( char  *string )
{
  int  i = 0;
  while ( ( string[i] = toupper( string[i] ) ) != '\0') i++;
  return string;
}


int WriteStringToFile (char*  ptrStr,
                       FILE**  ptrFd)
{
    int  error ;

    error = fputs (ptrStr, *ptrFd) ;
    if (error == EOF) {
        printf ("%s: Can't write in the file\n", argP) ;
        error = ERR_NOK ;
    }
    else {
        error = ERR_OK ;
    }
    return (error);
}


int WriteLongToFile (ulong  value,
                     FILE**  ptrFd)
{
    char  str[10] ;
     int  ii ;
     int  error ;

    CvLongToStringI (value, str) ;

    for ( ii = 0 ; ii < 4 ; ii++  ) {
        error = fputc (str[ii], *ptrFd) ;
        if (error == EOF) {
            printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
    }
    return (error);
}


int WriteShortToFile (ulong  value,
                      FILE**  ptrFd)
{
    char  str[10] ;
     int  ii ;
     int  error ;

    CvShortToStringI (value, str) ;

    for ( ii = 0 ; ii < 2 ; ii++ ) {
        error = fputc (str[ii], *ptrFd) ;
        if (error == EOF) {
            printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
    }
    return (error);
}


int ReadFileLength (ulong*  ptrLen,
                    FILE**  ptrFd)
{
    long  nbByte ;
     int  error ;

    do {
        *ptrLen = 0 ;

        /* Seek to the end of the source file */
        error = fseek (*ptrFd, 0, SEEK_END) ;
        if (error != ERR_OK) {
            printf ("%s: Can't seek the file\n", argP) ;
            break ;
        }

        /* Get the length of the source file */
        nbByte = ftell (*ptrFd) ;
        if (nbByte == ERR_NOK) {
            printf ("%s: Can't ftell the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }

        /* Seek to the begining of the source file */
        error = fseek (*ptrFd, 0, SEEK_SET) ;
        if (error != ERR_OK) {
            printf ("%s: Can't seek the file\n", argP) ;
            break ;
        }

        if (nbByte == 0) {
            printf ("%s: Source file is empty\n", argP) ;
            error = ERR_NOK ;
            break ;
        }

        *ptrLen = nbByte ;

    } while (0) ;
    return (error);
}


int LengthAndIdentOfBinTap (ulong  type,
                            ulong  pcId,
                            ulong  nbByte,
                            ulong  nbSync,
                            ulong*  ptrIdent,
                            ulong*  ptrSamp)
{
    ulong  ident ;
    ulong  nbSamp ;
      int  error ;

    do {
        error = ERR_OK ;
        switch (pcId) {
        case 1500 :
            if (type == TYPE_BIN) {
                /* Footer = 3 bytes : sum, 0x55 */
                ident = IDENT_PC15_BIN ;
                nbSamp = 3 ;
            }
            else {
                /* Footer = 4 bytes : 0xFF, sum, 0x55 */
                ident = IDENT_PC15_BAS ;
                nbSamp = 4 ;
            }

            /* Header = 42, Lead = nbByte + 2 * (nbByte / 80) */
            /* One Byte = 22 bits, each Bit = 16 Samples      */
            /* One Sync = one Bit = 16 Samples (2500 Hz)      */
            /* Ident  = 11 bits, 3 gaps of 70 bits            */

            nbSamp = nbSamp + 42 + nbByte + 2 * (nbByte / 80) ;
            nbSamp = nbSamp * 22 * 16 ;
            nbSamp = nbSamp + (nbSync * 16) ;
            nbSamp = nbSamp + (221 * 16) ;
            break ;

        case 1245 :
        case 1251 :
            if (type == TYPE_BIN) {
                ident = IDENT_OLD_BIN ;
                nbSamp = 1 + (2 * 9) ;  /* Header = 19 Byte */
            }
            else {
                ident = IDENT_OLD_BAS ;
                nbSamp = 1 + 9 ;        /* Header = 10 Byte */
            }

            /* Footer = 1, Lead = nbByte + (nbByte / 8)  */
            /* One Byte = 19 bits, each Bit = 16 Samples */
            /* One Sync = one Bit = 16 Samples (4000 Hz) */

            nbSamp = nbSamp + 1 + nbByte + (nbByte / 8) ;
            nbSamp = nbSamp * 19 * 16 ;
            nbSamp = nbSamp + (nbSync * 16) ;
            break ;

        case 1261 :
        case 1350 :
        case 1360 :
        case 1401 :
        case 1402 :
        case 1403 :
        case 1450 :
        case 1475 :
            if (type == TYPE_BIN) {
                ident = IDENT_NEW_BIN ;
                nbSamp = (1 + (2 * 9)) * 16 * 16 ;  /* Header = 19 Byte16 */
            }
            else {
                if ( (pcId == 1360) ||
                     (pcId == 1475) )
                    ident = IDENT_EXT_BAS ;
                else
                    ident = IDENT_NEW_BAS ;

                nbSamp = (1 + 9) * 16 * 16 ;        /* Header = 10 Byte16 */
            }

            /* Footer = 3 Byte13                         */
            /* Lead = (nbByte + (nbByte / 120)) Byte13   */
            /* Byte = 16 or 13 bits, Bit = 16 Samples    */
            /* Sync = one Bit = 16 Samples (4000 Hz)     */
	    /* there are 2bits more HIGH at the end of transmission (at least for PC-1402) M. NOSSWITZ */ 

            nbSamp = nbSamp + ((nbByte + 3 + (nbByte / 120)) * 13 * 16) ;
            nbSamp = nbSamp + (nbSync * 16) ;
	    nbSamp = nbSamp + 32 ;
            break ;

        default :
            nbSamp = 0 ;
            ident  = 0 ;
            break ;
        }

        *ptrIdent = ident ;
        *ptrSamp  = nbSamp ;

    } while (0) ;
    return (error);
}


int WriteHeadToTap (ulong  nbSamp,
                    ulong  freq,
                    FileInfo*  ptrFile)
{
/*    int  error ;

    do {
        error = WriteStringToFile ("RIFF", &ptrFile->ptrFd) ;
        if (error != ERR_OK) break ;

        error = WriteLongToFile ((nbSamp + 36), &ptrFile->ptrFd) ;
        if (error != ERR_OK) break ;

        error = WriteStringToFile ("WAVEfmt ", &ptrFile->ptrFd) ;
        if (error != ERR_OK) break ;

        error = WriteLongToFile (0x10, &ptrFile->ptrFd) ;
        if (error != ERR_OK) break ;

        error = WriteShortToFile (1, &ptrFile->ptrFd) ;      // PCM 
        if (error != ERR_OK) break ;

        error = WriteShortToFile (1, &ptrFile->ptrFd) ;      // Mono
        if (error != ERR_OK) break ;

        error = WriteLongToFile (freq, &ptrFile->ptrFd) ;    // Samp Freq
        if (error != ERR_OK) break ;

        error = WriteLongToFile (freq, &ptrFile->ptrFd) ;    // Byte / sec
        if (error != ERR_OK) break ;

        error = WriteShortToFile (1, &ptrFile->ptrFd) ;      // Byte / Samp x Chan 
        if (error != ERR_OK) break ;

        error = WriteShortToFile (8, &ptrFile->ptrFd) ;      // Bit / Samp 
        if (error != ERR_OK) break ;

        error = WriteStringToFile ("data", &ptrFile->ptrFd) ;
        if (error != ERR_OK) break ;

        error = WriteLongToFile (nbSamp, &ptrFile->ptrFd) ;  // Nb Samples 
        if (error != ERR_OK) break ;

    } while (0) ;
    return (error); */
    return ERR_OK;
}

int WriteBitToWav (ulong  value,
                   FileInfo*  ptrFile)
{
/*      int  ii ;
      int  error ;
    uchar  outb;
	
    for ( ii = 0 ; ii < 16 ; ii++ ) {
	if (bit[value][ii]) outb = 0xDA; else outb = 0x25;    
        error = fputc (outb, ptrFile->ptrFd) ;
        if (error == EOF) {
            printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
    }
    return (error); */
    return ERR_OK;
}


int WriteSyncToTap (int  nbSync,
                    FileInfo*  ptrFile)
{
/*    int  ii ;
    int  error ;

    do {
        // Write the Synchro patern 
        for ( ii = 0 ; ii < nbSync ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

    } while (0) ;
    return (error); */
    return ERR_OK;
}


int WriteQuaterToTap (ulong  value,
                      ulong  nbBits,
                      FileInfo*  ptrFile)
{
    ulong  tmp ;
      int  ii ;
      int  error ;

	do {
		error = fputc (0xF0 | value, ptrFile->ptrFd) ;
    	if (error == EOF) {
        	printf ("%s: Can't write in the file\n", argP) ;
        	error = ERR_NOK ;
        	break ;
    	}
    	else
        	error = ERR_OK ;
	} while (0);
/*    do {
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToTap (0, ptrFile) ;
            else
                error = WriteBitToTap (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < nbBits ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

    } while (0) ; */
    return (error);
}


int WriteByteToTap (ulong  value,
                    ulong  order,
                    ulong  mode,
                    FileInfo*  ptrFile)
{
    ulong  lsq ;
    ulong  msq ;
      int  error ;

    do {
        lsq = value & 0x0F ;
        msq = (value >> 4) & 0x0F ;
        if (order == ORDER_INV) {
	        error = fputc (0xF0 | lsq, ptrFile->ptrFd) ;
        	if (error == EOF) {
            	printf ("%s: Can't write in the file\n", argP) ;
            	error = ERR_NOK ;
            	break ;
        	}
        	else
            	error = ERR_OK ;
	        error = fputc (0xF0 | msq, ptrFile->ptrFd) ;
        	if (error == EOF) {
            	printf ("%s: Can't write in the file\n", argP) ;
            	error = ERR_NOK ;
            	break ;
        	}
        	else
            	error = ERR_OK ;
/*            error = WriteQuaterToWav (lsq, Mode[mode].nb1, ptrFile) ;
            if (error != ERR_OK) break ;
            error = WriteQuaterToWav (msq, Mode[mode].nb2, ptrFile) ;
            if (error != ERR_OK) break ; */
        }
        else {
	        error = fputc (0xF0 | msq, ptrFile->ptrFd) ;
        	if (error == EOF) {
            	printf ("%s: Can't write in the file\n", argP) ;
            	error = ERR_NOK ;
            	break ;
        	}
        	else
            	error = ERR_OK ;
	        error = fputc (0xF0 | lsq, ptrFile->ptrFd) ;
        	if (error == EOF) {
            	printf ("%s: Can't write in the file\n", argP) ;
            	error = ERR_NOK ;
            	break ;
        	}
        	else
            	error = ERR_OK ;
/*            error = WriteQuaterToWav (msq, Mode[mode].nb1, ptrFile) ;
            if (error != ERR_OK) break ;
            error = WriteQuaterToWav (lsq, Mode[mode].nb2, ptrFile) ;
            if (error != ERR_OK) break ; */
        }

    } while (0) ;
    return (error);
}


int WriteByteSumToTap (ulong  value,
                       ulong  order,
                       ulong  mode,
                       FileInfo*  ptrFile)
{
    int  error ;

    do {
        error = WriteByteToTap (value, order, mode, ptrFile) ;
        if (error != ERR_OK) break ;

        ptrFile->count = ptrFile->count + 1;
        switch (mode) {
        case MODE_B22 :
            if ( (ptrFile->count % 80) == 0) {
            }
            break ;

        case MODE_B21 :
        case MODE_B20 :
        case MODE_B19 :
            if ( (ptrFile->count % 8) == 0) {
            }
            break ;

        case MODE_B17 :
        case MODE_B16 :
        case MODE_B14 :
        case MODE_B13 :
            if ( (ptrFile->count % 120) == 0) {
            }
            break ;

        default :
            printf ("%s: Unknown Mode\n", argP) ;
            break ;
        }

    } while (0) ;
    return (error);
}


int WriteIdentToB22Tap (ulong  value,
                        FileInfo*  ptrFile)
{
    ulong  tmp ;
      int  ii ;
      int  error ;
      
    do {
      	error = fputc (0xF0 | value, ptrFile->ptrFd) ;
      	if (error == EOF) {
        	printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
	} while (0);	
/*
    do {
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 6 ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

    } while (0) ; */
    return (error); 
}


int WriteByteToB22Tap (ulong  value,
                       FileInfo*  ptrFile)
{
      int  error ;
      
    do {
      	error = fputc (value, ptrFile->ptrFd) ;
      	if (error == EOF) {
        	printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
	} while (0);	
/*    ulong  tmp ;
      int  ii ;
      int  error ;

    do {
    	error = Write
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 6 ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 4 ; ii < 8 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 6 ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

    } while (0) ; */
    return (error); 
}


int WriteByteToB19Wav (ulong  value,
                       FileInfo*  ptrFile)
{
      int  error ;
      
    do {
      	error = fputc (value, ptrFile->ptrFd) ;
      	if (error == EOF) {
        	printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
	} while (0);	
/*    ulong  tmp ;
      int  ii ;
      int  error ;

    do {
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 4 ; ii < 8 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 5 ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

    } while (0) ; */
    return (error);
}


int WriteByteToB16Wav (ulong  value,
                       FileInfo*  ptrFile)
{
      int  error ;
      
    do {
      	error = fputc (value, ptrFile->ptrFd) ;
      	if (error == EOF) {
        	printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
	} while (0);	
/*    ulong  tmp ;
      int  ii ;
      int  error ;

    do {
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 4 ; ii < 8 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        error = WriteBitToWav (1, ptrFile) ;
        if (error != ERR_OK) break ;
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 5 ; ii++ ) {
            error = WriteBitToWav (1, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

    } while (0) ; */
    return (error);
}


int WriteByteToB13Wav (ulong  value,
                       FileInfo*  ptrFile)
{
      int  error ;
      
    do {
      	error = fputc (value, ptrFile->ptrFd) ;
      	if (error == EOF) {
        	printf ("%s: Can't write in the file\n", argP) ;
            error = ERR_NOK ;
            break ;
        }
        else
            error = ERR_OK ;
	} while (0);	
/*    ulong  tmp ;
      int  ii ;
      int  error ;

    do {
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 4 ; ii < 8 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        error = WriteBitToWav (1, ptrFile) ;
        if (error != ERR_OK) break ;
        error = WriteBitToWav (0, ptrFile) ;
        if (error != ERR_OK) break ;

        for ( ii = 0 ; ii < 4 ; ii++ ) {
            tmp = 1 << ii ;
            if ( (value & tmp) == 0 )
                error = WriteBitToWav (0, ptrFile) ;
            else
                error = WriteBitToWav (1, ptrFile) ;

            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        error = WriteBitToWav (1, ptrFile) ;
        if (error != ERR_OK) break ;
        error = WriteBitToWav (1, ptrFile) ;
        if (error != ERR_OK) break ;

    } while (0) ; */
    return (error);
}


int WriteByteSumToB22Tap (ulong  value,
                          FileInfo*  ptrFile)
{
    ulong  cnt ;
    ulong  sum ;
    ulong  tmpL ;
      int  error ;

    do {
        cnt = ptrFile->count ;
        sum = ptrFile->sum ;

        /* Write the byte */
        error = WriteByteToB22Tap (value, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Update the SumCheck and the Byte Counter */
        sum = sum + value ;
        cnt = cnt + 1 ;

        if (cnt >= 80) {
            /* Write the SumCheck */
            tmpL = (sum >> 8) & 0xFF ;
            error = WriteByteToB22Tap (tmpL, ptrFile) ;
            if (error != ERR_OK) break ;

            tmpL = sum & 0xFF ;
            error = WriteByteToB22Tap (tmpL, ptrFile) ;
            if (error != ERR_OK) break ;

            cnt = 0 ;
            sum = 0 ;
        }

        ptrFile->count = cnt ;
        ptrFile->sum   = sum ;

    } while (0) ;
    return (error);
}


int WriteByteSumToB19Wav (ulong  value,
                          FileInfo*  ptrFile)
{
    ulong  cnt ;
    ulong  sum ;
      int  error ;

    do {
        cnt = ptrFile->count ;
        sum = ptrFile->sum ;

        /* Write the byte */
        error = WriteByteToB19Wav (value, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Update the SumCheck */
        sum = sum + ((value & 0xF0) >> 4) ;
        if (sum > 0xFF)
            sum = (sum + 1) & 0xFF ;
        sum = (sum + (value & 0x0F)) & 0xFF ;

        /* Update the Byte Counter */
        cnt = cnt + 1 ;

        if ( (cnt % 8) == 0 ) {
            /* Write the SumCheck */
            error = WriteByteToB19Wav (sum, ptrFile) ;
            if (error != ERR_OK) break ;

            if (cnt >= 80) {
                cnt = 0 ;
                sum = 0 ;
            }
        }

        ptrFile->count = cnt ;
        ptrFile->sum   = sum ;

    } while (0) ;
    return (error);
}


int WriteByteSumToB16Wav (ulong  value,
                          FileInfo*  ptrFile)
{
    ulong  cnt ;
    ulong  sum ;
      int  error ;

    do {
        cnt = ptrFile->count ;
        sum = ptrFile->sum ;

        /* Write the byte */
        error = WriteByteToB16Wav (value, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Update the SumCheck */
        sum = sum + ((value & 0xF0) >> 4) ;
        if (sum > 0xFF)
            sum = (sum + 1) & 0xFF ;
        sum = (sum + (value & 0x0F)) & 0xFF ;

        /* Update the Byte Counter */
        cnt = cnt + 1 ;

        if (cnt >= 8) {
            /* Write the SumCheck */
            error = WriteByteToB16Wav (sum, ptrFile) ;
            if (error != ERR_OK) break ;

            cnt = 0 ;
            sum = 0 ;
        }

        ptrFile->count = cnt ;
        ptrFile->sum   = sum ;

    } while (0) ;
    return (error);
}


int WriteByteSumToB13Wav (ulong  value,
                          FileInfo*  ptrFile)
{
    ulong  cnt ;
    ulong  sum ;
      int  error ;

    do {
        cnt = ptrFile->count ;
        sum = ptrFile->sum ;

        /* Write the byte */
        error = WriteByteToB13Wav (value, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Update the SumCheck */
        sum = sum + ((value & 0xF0) >> 4) ;
        if (sum > 0xFF)
            sum = (sum + 1) & 0xFF ;
        sum = (sum + (value & 0x0F)) & 0xFF ;

        /* Update the Byte Counter */
        cnt = cnt + 1 ;

        if (cnt >= 120) {
            /* Write the SumCheck */
            error = WriteByteToB13Wav (sum, ptrFile) ;
            if (error != ERR_OK) break ;

            cnt = 0 ;
            sum = 0 ;
        }

        ptrFile->count = cnt ;
        ptrFile->sum   = sum ;

    } while (0) ;
    return (error);
}


int WriteHeadToB22Tap (char*  ptrName,
                       ulong  addr,
                       ulong  size,
                       ulong  type,
                       FileInfo*  ptrFile)
{
      int  ii ;
    ulong  len ;
    ulong  tmpL ;
     char  tmpS[20] ;
      int  error ;

    do {
        /* Search the length */
        tmpL = strlen (ptrName) ;
        if (tmpL > 16)
            tmpL = 16 ;

        for ( ii = 0 ; ii < tmpL ; ii++ )
            tmpS[ii] = ptrName[ii] ;
        for ( ii = tmpL ; ii < 16 ; ii++ )
            tmpS[ii] = 0 ;

        if (Qcnt == 0) printf ("Save name    : %s\n", tmpS) ;

        /* Write the Header */
        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;
        for ( ii = 0x10 ; ii < 0x18 ; ii++ ) {
            error = WriteByteSumToB22Tap (ii, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        /* Write the first Sub-Ident */
        if (type == TYPE_BIN)
            tmpL = 0x00 ;
        else
            tmpL = 0x01 ;

        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Write the Name */
        for ( ii = 0 ; ii < 16 ; ii++ ) {
            error = WriteByteSumToB22Tap (tmpS[ii], ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        /* Write 9 null bytes */
        for ( ii = 0 ; ii < 9 ; ii++ ) {
            error = WriteByteSumToB22Tap (0, ptrFile) ;
            if (error != ERR_OK) break ;
        }
        if (error != ERR_OK) break ;

        /* Write the Addresse */
        tmpL = (addr >> 8) & 0xFF ;
        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = addr & 0xFF ;
        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Write the Buffer Size */
        if (type == TYPE_BIN)
            len = size - 1 ;
        else
            len = size ;

        tmpL = (len >> 8) & 0xFF ;
        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = len & 0xFF ;
        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Write the Sub-Ident */
        if (type == TYPE_BIN)
            tmpL = 0xFF ;
        else
            tmpL = 0x00 ;

        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteByteSumToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Write the SumCheck */
        tmpL = (ptrFile->sum >> 8) & 0xFF ;
        error = WriteByteToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = ptrFile->sum & 0xFF ;
        error = WriteByteToB22Tap (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteSyncToTap (70, ptrFile) ;
        if (error != ERR_OK) break ;

        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;

    } while (0) ;
    return (error);
}


int WriteSaveNameToB19Wav (char*  ptrName,
                           FileInfo*  ptrFile)
{
      int  ii ;
    ulong  byte ;
    ulong  tmpL ;
    char*  ptrDot ;
     char  tmpS[10] ;
      int  error ;

    do {
        /* Upercase the Name */
        (void) strupr (ptrName) ;
        tmpL = strlen (ptrName) ;
        if (tmpL > 7)
            tmpL = 7 ;

        for ( ii = 0 ; ii < tmpL ; ii++ )
            tmpS[ii] = ptrName[ii] ;
        tmpS[tmpL] = 0 ;
        if (Qcnt == 0) printf ("Save name    : %s\n", tmpS) ;

        tmpL = 7 - tmpL ;
        for ( ii = 0 ; ii < tmpL ; ii++ )
            tmpS[ii] = 0 ;

        for ( ii = tmpL ; ii < 7 ; ii++ ) {
            byte = (ulong) ptrName[6 - ii] ;
            if (byte < 0x80)
                byte = CodeOld[byte] ;
            else
                byte = CodeOld[0] ;

            tmpS[ii] = (char) ( (byte >> 4) + ((byte << 4) & 0xF0) ) ;
        }
        tmpS[7] = 0x5F ;

        /* Write the Name */
        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;
        for ( ii = 0 ; ii < 8 ; ii++ ) {
            error = WriteByteSumToB19Wav (tmpS[ii], ptrFile) ;
            if (error != ERR_OK) break ;
        }
        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;

    } while (0) ;
    return (error);
}


int WriteSaveNameToB16Wav (char*  ptrName,
                           FileInfo*  ptrFile)
{
      int  ii ;
    ulong  byte ;
    ulong  tmpL ;
    char*  ptrDot ;
     char  tmpS[10] ;
      int  error ;

    do {
        /* Search the Dot position */
        tmpL = strlen (ptrName) ;
        if (tmpL > 7)
            tmpL = 7 ;

        for ( ii = 0 ; ii < tmpL ; ii++ )
            tmpS[ii] = ptrName[ii] ;
        tmpS[tmpL] = 0 ;
        if (Qcnt == 0) printf ("Save name    : %s\n", tmpS) ;

        tmpL = 7 - tmpL ;
        for ( ii = 0 ; ii < tmpL ; ii++ )
            tmpS[ii] = 0 ;

        for ( ii = tmpL ; ii < 7 ; ii++ ) {
            byte = (ulong) ptrName[6 - ii] ;
            if (byte >= 0x80)
                byte = 0x20 ;

            tmpS[ii] = (char) ( (byte >> 4) + ((byte << 4) & 0xF0) ) ;
        }
        tmpS[7] = 0x5F ;

        /* Write the Name */
        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;
        for ( ii = 0 ; ii < 8 ; ii++ ) {
            error = WriteByteSumToB16Wav (tmpS[ii], ptrFile) ;
            if (error != ERR_OK) break ;
        }
        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;

    } while (0) ;
    return (error);
}


int WriteHeadToB19BinWav (ulong  addr,
                          ulong  size,
                          FileInfo*  ptrFile)
{
      int  ii ;
    ulong  len ;
    ulong  tmpL ;
      int  error ;

    do {
        if (Qcnt == 0)
	{	
    		printf ("Start Address: 0x%04X\n", (uint) addr);
		printf ("Buffer Length: %d bytes\n", (uint) size);
	}	

        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;
        for ( ii = 0 ; ii < 4 ; ii++ ) {
            error = WriteByteSumToB19Wav (0, ptrFile) ;
            if (error != ERR_OK) break ;
        }

        /* Write the Addresse */
        tmpL = ((addr >> 4) & 0xF0) + (addr >> 12) ;
        error = WriteByteSumToB19Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = ((addr << 4) & 0xF0) + ((addr >> 4) & 0x0F) ;
        error = WriteByteSumToB19Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Write the Length */
        len = size - 1 ;
        tmpL = ((len >> 4) & 0xF0) + (len >> 12) ;
        error = WriteByteSumToB19Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = ((len << 4) & 0xF0) + ((len >> 4) & 0x0F) ;
        error = WriteByteSumToB19Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;

    } while (0) ;
    return (error);
}


int WriteHeadToB16BinWav (ulong  addr,
                          ulong  size,
                          FileInfo*  ptrFile)
{
      int  ii ;
    ulong  len ;
    ulong  tmpL ;
      int  error ;

    do {
        if (Qcnt == 0)
	{
		printf ("Start Address: 0x%04X\n", (uint) addr);
		printf ("Buffer Length: %d bytes\n", (uint) size);
	}	

        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;
        for ( ii = 0 ; ii < 4 ; ii++ ) {
            error = WriteByteSumToB16Wav (0, ptrFile) ;
            if (error != ERR_OK) break ;
        }

        /* Write the Addresse */
        tmpL = ((addr >> 4) & 0xF0) + (addr >> 12) ;
        error = WriteByteSumToB16Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = ((addr << 4) & 0xF0) + ((addr >> 4) & 0x0F) ;
        error = WriteByteSumToB16Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        /* Write the Length */
        len = size - 1 ;
        tmpL = ((len >> 4) & 0xF0) + (len >> 12) ;
        error = WriteByteSumToB16Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        tmpL = ((len << 4) & 0xF0) + ((len >> 4) & 0x0F) ;
        error = WriteByteSumToB16Wav (tmpL, ptrFile) ;
        if (error != ERR_OK) break ;

        ptrFile->count = 0 ;
        ptrFile->sum   = 0 ;

    } while (0) ;
    return (error);
}


int WriteFooterToB22BinTap (ulong  type,
                            FileInfo*  ptrFile)
{
    ulong  sum ;
      int  error ;

    do {
        ptrFile->count = 0 ;
        if (type != TYPE_BIN) {
            error = WriteByteSumToB22Tap (0xFF, ptrFile) ;
            if (error != ERR_OK) break ;
        }

        sum = (ptrFile->sum >> 8) & 0xFF ;
        error = WriteByteToB22Tap (sum, ptrFile) ;
        if (error != ERR_OK) break ;

        sum = ptrFile->sum & 0xFF ;
        error = WriteByteToB22Tap (sum, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteSyncToTap (70, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteByteToB22Tap (0x55, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteSyncToTap (70, ptrFile) ;
        if (error != ERR_OK) break ;

    } while (0) ;
    return (error);
}


int WriteFooterToB13BinWav (FileInfo*  ptrFile)
{
    ulong  sum ;
      int  error ;

    do {
        ptrFile->count = 0 ;
        error = WriteByteSumToB13Wav (0xFF, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteByteToB13Wav (0xFF, ptrFile) ;
        if (error != ERR_OK) break ;

        error = WriteByteToB13Wav (ptrFile->sum, ptrFile) ;
        if (error != ERR_OK) break ;
	    
	/* there are 2bits more HIGH at the end of transmission (at least for PC-1402) M. NOSSWITZ */     
	error = WriteBitToWav (1, ptrFile) ;
	if (error != ERR_OK) break ;       
	error = WriteBitToWav (1, ptrFile) ;        
	if (error != ERR_OK) break ;     

    } while (0) ;
    return (error);
}


int ConvertBinToTap (char*  ptrSrcFile,
                     char*  ptrDstFile,
                     ulong  type,
                     ulong  pcId,
                     ulong  addr,
                     ulong  nbSync,
                     char*  ptrName)
{
    FileInfo  info ;
        FILE  *srcFd ;
         int  inVal ;
         int  ii ;
       ulong  nbByte ;
       ulong  nbSamp ;
       ulong  freq ;
       ulong  sync ;
         int  error ;

    do {
        info.ptrFd = NULL ;
        info.ident = IDENT_UNKNOWN ;
        info.count = 0 ;
        info.sum   = 0 ;
        srcFd      = NULL ;
        error      = ERR_OK ;

        /* Open the destination file */
        info.ptrFd = fopen (ptrDstFile, "wb") ;
        if (info.ptrFd == NULL) {
            printf ("%s: Can't open the destination file: %s\n", argP, ptrDstFile) ;
            error = ERR_NOK ;
            break ;
        }

        /* Open the source file */
        srcFd = fopen (ptrSrcFile, "rb") ;
        if (srcFd == NULL) {
            printf ("%s: Can't open the source file: %s\n", argP, ptrSrcFile) ;
            error = ERR_NOK ;
            break ;
        }

        error = ReadFileLength (&nbByte, &srcFd) ;
        if (error != ERR_OK) break ;

        if (nbByte > 0x10000) {
            printf ("%s: Source file contains more than 65536 bytes\n", argP) ;
            error = ERR_NOK ;
            break ;
        }

        if ( (addr + nbByte) > 0x10000) {
            printf ("%s: (Address + Size) greater than 65536)\n", argP) ;
            error = ERR_NOK ;
            break ;
        }

        if (pcId == 1500)
            freq = BASE_FREQ2 ;
        else
            freq = BASE_FREQ1 ;

        sync = (nbSync * freq) / 8 ;

        /* Calculate the length and Ident of the destination file */
        error = LengthAndIdentOfBinTap (type, pcId, nbByte, sync, &info.ident, &nbSamp) ;
        if (error != ERR_OK) break ;

        /* Write the header of the destination WAV file */
        error = WriteHeadToTap (nbSamp, (freq *2), &info) ;
        if (error != ERR_OK) break ;

        /* Write the synchro patern for N times */
        if (Qcnt == 0) printf ("Synchro size : %d bits\n", sync);
        error = WriteSyncToTap (sync, &info) ;
        if (error != ERR_OK) break ;
	
	if (Qcnt == 0) {		
        printf ("Tape format  : 0x%02X <- ", (uchar) info.ident) ;
        if (type == TYPE_BIN)
            printf ("Binary, PC-%d\n", pcId) ;
        else
            printf ("Basic, PC-%d\n", pcId) ;
	}

        if (pcId == 1500) {
            /* Write the TAP code */
            error = WriteIdentToB22Tap (IDENT_PC1500, &info) ;
            if (error != ERR_OK) break ;

            /* Write the Name */
            error = WriteHeadToB22Tap (ptrName, addr, nbByte, type, &info) ;
            if (error != ERR_OK) break ;

            if ((type == TYPE_BIN) && (Qcnt == 0)) {
                printf ("Start Address: 0x%04X\n", (uint) addr);
                printf ("Buffer Length: %d bytes\n", (uint) nbByte);
            }
        }

        if ( (info.ident == IDENT_OLD_BAS) ||
             (info.ident == IDENT_OLD_BIN) ) {
            /* Write the TAP code */
            error = WriteByteToB19Wav (info.ident, &info) ;
            if (error != ERR_OK) break ;

            /* Write the Name */
            error = WriteSaveNameToB19Wav (ptrName, &info) ;
            if (error != ERR_OK) break ;
        }

        if ( (info.ident == IDENT_NEW_BAS) ||
             (info.ident == IDENT_EXT_BAS) ||
             (info.ident == IDENT_NEW_BIN) ) {
            /* Write the TAP code */
            error = WriteByteToB16Wav (info.ident, &info) ;
            if (error != ERR_OK) break ;

            /* Write the Name */
            error = WriteSaveNameToB16Wav (ptrName, &info) ;
            if (error != ERR_OK) break ;
        }

        switch (info.ident) {
        case IDENT_PC15_BAS :
            /* Write the datas */
            do {
                inVal = fgetc (srcFd) ;
                if (inVal == EOF) break ;

                error = WriteByteSumToB22Tap (inVal, &info) ;
                if (error != ERR_OK) break ;

            } while (1) ;
            if (error != ERR_OK) break ;

            /* Write the END code */
            error = WriteFooterToB22BinTap (type, &info) ;
            break ;

        case IDENT_PC15_BIN :
            /* Write the datas */
            do {
                inVal = fgetc (srcFd) ;
                if (inVal == EOF) break ;

                error = WriteByteSumToB22Tap (inVal, &info) ;
                if (error != ERR_OK) break ;

            } while (1) ;
            if (error != ERR_OK) break ;

            /* Write the END code */
            error = WriteFooterToB22BinTap (type, &info) ;
            break ;

        case IDENT_OLD_BAS :
            /* Write the datas */
            do {
                inVal = fgetc (srcFd) ;
                if (inVal == EOF) break ;

                error = WriteByteSumToB19Wav (inVal, &info) ;
                if (error != ERR_OK) break ;

            } while (1) ;
            if (error != ERR_OK) break ;

            /* Write the END code */
            error = WriteByteToB19Wav (0xF0, &info) ;
            break ;

        case IDENT_OLD_BIN :
            /* Write the addresse and length */
            error = WriteHeadToB19BinWav (addr, nbByte, &info) ;
            if (error != ERR_OK) break ;

            /* Write the datas */
            do {
                inVal = fgetc (srcFd) ;
                if (inVal == EOF) break ;

                error = WriteByteSumToB19Wav (inVal, &info) ;
                if (error != ERR_OK) break ;

            } while (1) ;
            if (error != ERR_OK) break ;

            /* Write the END code */
            error = WriteByteToB19Wav (0xF0, &info) ;

            break ;

        case IDENT_NEW_BAS :
        case IDENT_EXT_BAS :
            /* Write the datas */
            do {
                inVal = fgetc (srcFd) ;
                if (inVal == EOF) break ;

                error = WriteByteSumToB13Wav (inVal, &info) ;
                if (error != ERR_OK) break ;

            } while (1) ;
            if (error != ERR_OK) break ;

            /* Write the END code */
            error = WriteFooterToB13BinWav (&info) ;   
            break ;

        case IDENT_NEW_BIN :
            /* Write the addresse and length */
            error = WriteHeadToB16BinWav (addr, nbByte, &info) ;
            if (error != ERR_OK) break ;

            /* Write the datas */
            do {
                inVal = fgetc (srcFd) ;
                if (inVal == EOF) break ;

                error = WriteByteSumToB13Wav (inVal, &info) ;
                if (error != ERR_OK) break ;

            } while (1) ;
            if (error != ERR_OK) break ;

            /* Write the END code */
            error = WriteFooterToB13BinWav (&info) ;
            break ;

        default :
            printf ("%s: Unknown Ident\n", argP) ;
            break ;
        }

    } while (0) ;

    /* Close the source file */
    if (srcFd != NULL) {
        error = fclose (srcFd) ;
        if (error != ERR_OK) {
            printf ("%s: Can't close the source file\n", argP) ;
        }
    }

    /* Close the destination file */
    if (info.ptrFd != NULL) {
        error = fclose (info.ptrFd) ;
        if (error != ERR_OK) {
            printf ("%s: Can't close the destination file\n", argP) ;
        }
    }

    return (error);
}


void PrintHelp (void)  /* 1         2         3         4         5         6         7         8 */
{             /* 12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
	printf ("Usage: %s [Options] SrcFile [DstFile]\n", argP) ;
	printf ("SrcFile          : Binary image file (usualy produced by 'BAS2IMG' or 'WAV2BIN')\n") ;
	printf ("Options:\n") ;
	printf ("DstFile          : WAV file (default: SrcFile.wav)\n") ;
	printf ("-t, --type=TYPE  : Source file type\n") ;
	printf ("                    bin  Binary image file (Assembly program or Datas)\n") ;
	printf ("                    img  Binary image file (BASIC-program, default: img)\n") ;
//	printf ("-p, --pc=NUMBER  : Sharp pocket computer, currently available\n") ;
//	printf ("                    1245, 1251, 1261, 1350, 1360, 1401, 1402,\n") ;
//	printf ("                    1403, 1450, 1475, 1500 (default: 1500)\n") ;
	printf ("-p, --pc=NUMBER  : Sharp pocket computer, currently available\n") ;
	printf ("                    1245, 1251, 1261, 1500 (default: 1500)\n") ;
	printf ("-a, --addr=VALUE : Start addresse, needed for BIN type\n") ;
	printf ("                    0 to 65535, or 0x0000 to 0xFFFF (default: 0)\n") ;
	printf ("-s, --sync=VALUE : Synchronisation duration, expressed in seconds\n") ;
	printf ("                    1 to 8 (default: 2)\n") ;
	printf ("-n, --name=NAME  : Sharp file name (7 characters max, 16 for the PC-1500)\n") ;
	printf ("                    (default: DstFile without extension, nor path)\n") ;
	printf ("-q, --quiet      : Quiet mode (No display output)\n") ;
	printf ("    --help       : Display this information\n") ;
	printf ("    --version    : Display version information\n") ;
	exit( 1 ); /* no arguments were passed */
}


void PrintVersion (void)
{   	char  argPU[cLPF] = "" ;
	strcpy(argPU, argP) ;
	printf ("%s (%s) version: 1.4\n", strupr(argPU) ) ;
	printf ("Author: Pocket -> www.pocketmuseum.com\n") ; /* Please do not remove */
	printf ("        Modified for TAP format by O2S\n") ; /* Please do not remove */
	printf ("This is free software. There is NO warranty;\n") ;
    printf ("not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n") ;
	exit( 1 ); /* no arguments were passed */
}


void MoreInfo (void)
{	printf("%s: '%s --help' gives you more information\n", argP, argP);
	exit( 1 ); /* no arguments were passed */
}


int main ( int argc, char **argv )  /* (int argc, char* argv[]) */
{	/* 0=SrcFile 1=[DstFile] 2=[-t] 3=[-p] 4=[-a] 5=[-s] 6=[-n] */
	  char  argD[7][cLPF] = { "", "", "img", "1500", "0x0000", "2", "" } ;
	  char  argS[cLPF] = "", *ptrToken, *ptrErr, tmp ;
	  uint  FILEcnt = 0, Tcnt = 0, PCcnt = 0, Acnt = 0, Scnt = 0, Ncnt = 0 ;  
	 ulong  type, pcId, sync, addr ;
	   int  option_index, error, c ;
    static int  longval ;

        struct option long_options[] =
	{
		{"type",    required_argument, 0,        't'},
		{"pc",	    required_argument, 0,        'p'},
		{"addr",    required_argument, 0,        'a'},
		{"sync",    required_argument, 0,        's'},
		{"name",    optional_argument, 0,        'n'},
		{"quiet",   no_argument,       0,        'q'},
		{"version", no_argument,       &longval, 'v'}, /* long option only */
		{"help",    no_argument,       &longval, 'h'}, /* long option only */
	        {0, 0, 0, 0}
	};	
		
    /* ProgramName */
    if      (strrchr (argv[0], '\\')) strcpy(argP, 1 + strrchr (argv[0], '\\'));  /* Windows path separator '\' */
    else if (strrchr (argv[0], '/')) strcpy(argP, 1 + strrchr (argv[0], '/'));    /* Linux   path separator '/' */
    else strcpy(argP, argv[0]);
    if ( strrchr (argP, '.')) *(strrchr (argP, '.')) = '\0';                      /* Extension separator '.'    */
    
    do
    {    
	while (1) {
        error = ERR_OK ;
        addr  = 0 ;

	/* getopt_long stores the option index here. */
        option_index = 0;

	c = getopt_long (argc, argv, "t:p:a:s:n:qvh", long_options, &option_index);

	/* Detect the end of the options. */
        if (c == -1) break;
     
	switch (c)
        {
		case 't': strcpy( argD[2], optarg); Tcnt++; break;  
		case 'p': strcpy( argD[3], optarg); PCcnt++; break;
		case 'a': strcpy( argD[4], optarg); Acnt++; break;
		case 's': strcpy( argD[5], optarg); Scnt++; break;
		case 'n': { if ( optarg != 0 ) strcpy( argD[6], optarg);
			    Ncnt++; break; }
		case 'q': Qcnt++; break;
		case 0:
		  switch (longval) {	
		    case 'v': PrintVersion (); break;
		    case 'h': PrintHelp (); break;
		  } break;
		default : MoreInfo (); break;
        }
        }    
	
	if (optind < argc) /* get non-option ARGV-elements */
        {
          while (optind < argc) {
	    strcpy(argD[FILEcnt!=0], argv[optind++]);
	    FILEcnt++;
	  }  
        }

	if (FILEcnt < 1) { printf("%s: Missing Operand after '%s'\n", argP, argP); MoreInfo (); }
	if ((FILEcnt > 2) || (Tcnt > 1) || (PCcnt > 1) || (Acnt > 1) || (Scnt > 1) ||
            (Ncnt > 1) || (Qcnt > 1)) { printf("%s: Operand error in '%s'\n", argP, argP); MoreInfo (); }
	if (FILEcnt == 1)
	{
		if ( strrchr (argD[0], '.')) strncat (argD[1], argD[0], strrchr (argD[0], '.') - argD[0] ); /* GetSrcFile */
                strcat (argD[1], ".wav" );  /* DstFile=SrcFile.wav */
	}

        (void) strupr (argD[2]) ;
        type = TYPE_NOK ;
        if (strcmp (argD[2], "BIN") == 0)
            type = TYPE_BIN ;

        if (strcmp (argD[2], "IMG") == 0)
            type = TYPE_IMG ;

        if (type == TYPE_NOK) {
            printf ("%s: Source file type %s is not valid\n", argP, argD[2]) ;
            MoreInfo ();
            break ;
        }

        /* Compare the PC Ident to the allowed tokens */
        if (strlen (argD[3]) == 0) {
            printf ("%s: No pocket computer specified\n", argP) ;
            MoreInfo ();
            break ;
        }
        pcId = (ulong) strtol (argD[3], &ptrErr, 0) ;
        if (pcId == 0) {
            printf ("%s: Pocket computer %s is not valid\n", argP, argD[3]) ;
            MoreInfo ();
            break ;
        }

        switch (pcId) {
        case 1500 :
        case 1245 :
        case 1251 :
        case 1261 :
            break ;

        case 1350 :
        case 1360 :
        case 1401 :
        case 1402 :
        case 1403 :
        case 1450 :
        case 1475 :
        default :
            printf ("%s: Pocket computer %s not implemented\n", argP, argD[3]) ;
            MoreInfo ();
            error = ERR_NOK ;
            break ;
        }
        if (error != ERR_OK) break ;

        /* Convert the Address in a ulong if necessary */
        if (type == TYPE_BIN) {
            addr = (ulong) strtol (argD[4], &ptrErr, 0) ;
            if (*ptrErr != 0) { /* was (*ptrErr != NULL) */
                tmp = *ptrErr ;
                *ptrErr = 0 ;
                printf ("%s: Start address is not valid '%s -> ", argP, argD[4]) ;
                *ptrErr = tmp ;
                printf ("%s'\n", ptrErr) ;
                MoreInfo ();
                break ;
            }

            if ( (addr < 0) ||
                 (addr > 0xFFFF) ) {
                printf ("%s: Start address '%s' is out of range\n", argP, argD[4]) ;
                MoreInfo ();
                break ;
            }
        }

        /* Convert the Sync length in a ulong */
        sync = (ulong) strtol (argD[5], &ptrErr, 0) ;
        if (*ptrErr != 0) { /* was (*ptrErr != NULL) */
            tmp = *ptrErr ;
            *ptrErr = 0 ;
            printf ("%s: Sync length is not valid '%s -> ", argP, argD[5]) ;
            *ptrErr = tmp ;
            printf ("%s'\n", ptrErr) ;
            MoreInfo ();
            break ;
        }

        if ( (sync < 1) ||
             (sync > 10) ) {
            printf ("%s: Sync length '%s' is out of range\n", argP, argD[5]) ;
            MoreInfo ();
            break ;
        }

        /* Check if the name-option is used and no name is defined */
        if ( ( Ncnt == 1 ) && ( strlen (argD[6]) == 0 ) ) {
            /* Search the last colon position */
            ptrToken = strrchr (argD[1], CHAR_COLON) ;
            if (ptrToken == NULL)
                (void) strcpy (argS, argD[1]) ;
            else
                (void) strcpy (argS, ptrToken + 1) ;

            /* Search the last slash position */
            ptrToken = strrchr (argS, CHAR_SLASH) ;
            if (ptrToken == NULL)
                (void) strcpy (argD[6], argS) ;
            else
                (void) strcpy (argD[6], ptrToken + 1) ;

            /* Search the dot position */
            ptrToken = strchr (argD[6], CHAR_DOT) ;
            if (ptrToken != NULL)
                *ptrToken = 0 ;
        }	
	
        /* Replace the underscore with space in the name */
        ptrToken = strchr (argD[6], CHAR_UNDERSCORE) ;
        while (ptrToken != NULL) {
            *ptrToken = CHAR_SPACE ;
            ptrToken = strchr (argD[6], CHAR_UNDERSCORE) ;
        }

        /* Call the Convert function */
        (void) ConvertBinToTap (argD[0], argD[1], type, pcId, addr, sync, argD[6]) ;

    } while (0) ;
}