1) Introduction

• Tout d'abord le volume par défaut a la valeur 254 (quand vous tapez juste INIT HELLO, D1 par exemple).
  
  
• Le format d'image disk .dsk ne conserve pas cette information de volume. Ce qui veut dire que lorsque vous créez un .dsk, le volume de vos disquettes n'est pas mémorisé et lorsque vous mettez un .dsk dans votre émulateur, ce dernier considère d'office qu'il s'agit d'une disquette avec un volume = 254!
  
  
• Lorsque les éditeurs de logiciels ont sortis des jeux sur plusieurs disquettes (ce qui est souvent le cas pour les jeux d'aventure, par exemple pour la série des softs graphiques signés Sierra), bien souvent ils ont utilisé le numéro de volume comme identifiant de face. Donc à un moment, le soft recherche soit la face courante soit vous demande d'insérer un certain disque et il ne trouvera jamais la face attendue... d'où blocage sur cette face ou même plantage des fois.
  
  

2) Le programme dsk2nib

java -jar dsk2nib.jar 1 a.dsk b.dsk

java -jar dsk2nib.jar 254 *.dsk

java -jar dsk2nib.jar 55 *VOL55*.dsk

	java 1.5	Download dsk2nib.jar (class)
	java 1.5	Download dsk2nib_src.jar (sources)

3) Tests sous Windows XP

4) Tests sur mac intel OS X

5) Tests avec les jeux d'aventure Sierra

6) Compléments

King's Quest I: french crack (14/01/85) by Eric Irq & The Wildman (ABC = Association of Broadcasting Crackers)
--------------
                      Side A = 1, Side B = 2, Side C = 3


Kings Quest II: french crack (01/02/86) by Lockbuster & Binary Digit (LCB = Laser Crack Band) >>> Thry2
--------------  french crack (17/12/85) by Chris (Copyart)                                    >>> Deckard

                                Disk 1   Disk 2   Disk 3
                       Front      1        3        5
                       Back       2        4


Kings Quest III: french crack (27/06/88) by Godfather & Steff
---------------
                                Disk 1   Disk 2   Disk 3   Disk 4   Disk 5
                       Front      1        3        5        7        9
                       Back       2        4        6        8        10


King's Quest IV: french crack (14/05/1989) by Loockheed (TBT = The Brain Trust)
---------------
                                Disk 1   Disk 2   Disk 3   Disk 4   Disk 5   Disk 6   Disk 7   Disk 8
                       Front      1        3        5        7        9        11       13       15
                       Back       2        4        6        8        10       12       14       16


Space Quest I: french crack (??/??/????) by Softpatch (avec les explications de Lot)          >>> Thry2
-------------  unsigned                                                                       >>> Deckard

                                Disk 1   Disk 2   Disk 3   Disk 4
                       Front      1        3        5        7
                       Back       2        4        6        8


Space Quest II: french crack (04/05/1988) by Gerard & Goldpom
--------------
                                Disk 1   Disk 2   Disk 3   Disk 4
                       Front      1        3        5        7
                       Back       2        4        6        8


Leisure Suit Larry: french crack (??/??/????) by HackerForce (HF)                                 >>> Thry2
------------------  cracked (12/05/1987) by The Boy! (COD = Circle Of Deneb / BBS: The Lost City) >>> Deckard

                                Disk 1   Disk 2   Disk 3
                       Front      1        3        5
                       Back       2        4


Police Quest: The game was unprotected (distributed by The Brain Trust)
------------
                                Disk 1   Disk 2   Disk 3   Disk 4
                       Front      1        3        5        7
                       Back       2        4        6        8


Mixed-up Mother Goose: The game was unprotected (distributed by The Brain Trust)
---------------------
                                Disk 1   Disk 2
                       Front      1        3
                       Back       2        4


Gold Rush!: french crack (18/05/1990) by LoGo (TOD = The Thieves Of Destiny) presentation #1     >>> Thry2
----------  french crack (18/05/1990) by ???  (TOD = The Thieves Of Destiny) presentation #2     >>> Deckard

                                Disk 1   Disk 2   Disk 3   Disk 4   Disk 5   Disk 6   Disk 7   Disk 8
                       Front      1        3        5        7        9        11       13       15
                       Back       2        4        6        8        10       12       14       16


Manhunter: New York: french crack (20/06/1990) by LoGo (TOD = The Thieves Of Destiny)
-------------------
                                Disk 1   Disk 2   Disk 3   Disk 4   Disk 5   Disk 6
                       Front      1        3        5        7        9        11
                       Back       2        4        6        8        10       12


The Black Cauldron: unsigned
------------------
                                Disk 1   Disk 2   Disk 3
                       Front      1        3        5
                       Back       2        4


The Dark Crystal: french crack (13/03/1983) by Aldo Reset (CCB = Clean Crack Band)
----------------
                                Disk 1   Disk 2
                       Front      254      4
                       Back       3        5

7) Les sources de dsk2nib

import java.io.File;

/*
 * dsk2nib
 *
 * Deckard 20081114
 * Utilise la routine de nibblizing de l'applet Applelet (émulateur Apple II java)
 *
 */
public class dsk2nib {

    /**
     * @param args
     */
    public static void main(String[] args) {

        // Si pas assez de paramètres, rappel de la syntaxe de la commande
        if (args.length < 2) {
            System.err.println("Usage: java -jar dsk2nib.jar volume[1-254] .dsk file(s)");
            return;
        }

        // Vérifie que le volume renseigné est numérique
        if(!isNumeric(args[0])) {
            System.err.println("volume must be numeric!");
            return;
        }
       
        // Volume à affecter
        int vol = Integer.valueOf(args[0]).intValue();
        // Vérifie fourchette de validité
        if (vol < 1 || vol > 254) {
            System.err.println("Bad volume!");
            return;
        }

        // Traite les .dsk les 1 après les autres
        // A noter que si vous tapez *.dsk ou nom*.dsk, il y aura autant de parms que de fichiers matchés
        for (int i = 1; i < args.length; i++) {
            File f = new File(args[i]);

            // Vérifie que le .dsk est correct
            if (isDSKOkay(f)) {
                // Construit le nom du .nib à créer
                String nameNIB = new String(f.getName().substring(0, f.getName().length() -3).concat("nib") );       
                // Initialise le .nib en mémoire
                NIBImage myNIB = new NIBImage();
                // Alimentation depuis le .dsk
                myNIB.fillNIBWithDSK(f.getName(), vol);
                // Sauvegarde du .nib
                myNIB.saveNIB(nameNIB);
            }
       
        }

        System.out.println("FINISHED!");
       
    }

    /**
     * Test la numéricité d'une chaine
     *
     * @param String zoneTest (non null)
     * @return Boolean result
     */
    public static boolean isNumeric(String zoneTest) {
        // Décompose dans un tableau de char
        final char[] chars = zoneTest.toCharArray();
        // Teste chaque caractère
        for (int x = 0; x < chars.length; x++) {     
           final char c = chars[x];
           if ((c >= '0') && (c <= '9')) continue; // numeric
           return false;
         } 
         return true;
    }
   
    /**
     * Test un .dsk
     *
     * @param File f (non null)
     * @return Boolean result
     */
    public static boolean isDSKOkay(File f) {
       
        // Vérifie que c'est bien un .dsk
        if (!f.getName().toLowerCase().endsWith(".dsk")) {
            System.err.println(f.getName() + " is not a .dsk file!");
            return false;
        }
       
        // Vérifie que le nom de .dsk donné n'est pas bidon
        try {
            if (!f.exists()) {
                System.err.println("Can't find "  + f.getName() + "!");
                return false;
            }       
        } catch (SecurityException x) {
            System.err.println("Security err (exists)!");
        }

        // Vérifie la taille du .dsk
        try {
            if (f.length() != 143360) {
                System.err.println(f.getName() + " has a bad length!");
                return false;
            }
        } catch (SecurityException x) {
            System.err.println("Security err (length)!");
        }
       
        // OK
        return true;
       
    }
   
}

import java.io.FileInputStream;
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;


public class NIBImage
{
   // Contenu du .nib
   public byte data[][];
  
   // Nombre de pistes par face de disquette
   static int NUM_TRACKS = 35;
   // Nombre de secteurs par piste d'un .dsk
   static int NUM_SECTORS = 16;
   // Taille d'une piste du .nib
   static int TRACK_SIZE = 0x1a00;
   // Nombre de nibbles correspondant à 1 secteur complet du .dsk
   static int SECTOR_SIZE = 409;
  
  
   public NIBImage()
   {
       // Init l'espace de stockage
       data = new byte[NUM_TRACKS][TRACK_SIZE];
   }
  
    /*
     *  Alimentation du contenu du .nib en mémoire à partir du .dsk
     */
    void fillNIBWithDSK(String filename, int volume) {
        System.out.println("Loading disk image " + filename);
        try {
            FileInputStream imgFile = new FileInputStream(filename);
            DataInputStream s = new DataInputStream(imgFile);
            // Buffer contenant une piste du .dsk
            // 1 piste = 16 secteurs * 256 octets = 4096 = $1000
            byte buf[] = new byte[0x1000];
           
            // Lecture 1 à 1 des pistes du .dsk
            for (int trk = 0; trk < NUM_TRACKS; trk++) {
                // Stocke la piste lue dans le buffer buf
                s.readFully(buf, 0, 0x1000);
                // Alimente la piste équivalente du .nib
                this.data[trk] = NIBImage.nibblizeTrack(volume, trk, buf);
            }
           
        } catch (IOException e) {
            System.err.println("Could not load disk image");
        }
    }

    /*
     *  Sauvegarde du contenu du .nib en mémoire
     */
    void saveNIB(String filename) {
        System.out.println("Saving new disk image " + filename);
        try {
            FileOutputStream imgFile = new FileOutputStream(filename);
            DataOutputStream s = new DataOutputStream(imgFile);
           
            // Ecriture 1 à 1 des pistes du .nib
            for (int trk = 0; trk < NUM_TRACKS; trk++) {
                s.write(this.data[trk], 0, TRACK_SIZE);
            }
           
        } catch (IOException e) {
            System.err.println("Could not save new disk image");
        }
    }
  
       
    /*
     * Nibblize les 16 secteurs d'une piste de .dsk
     */
    public static byte[] nibblizeTrack(int vol, int trk, byte in[]) {
        // Buffer 1 piste du .nib
        byte out[] = new byte[TRACK_SIZE];
        // Pointeur dans le buffer de piste
        int out_pos = 0;

        // Remplit le buffer de piste avec les 16 secteurs nibblizés
        for (int sector = 0; sector < NUM_SECTORS; sector++) {
            nibblizeSector(vol, trk, sector, in, skewing_table[sector] << 8,
                    out, out_pos);
            // Positionne après le secteur traité
            out_pos += SECTOR_SIZE;
        }

        // Complète avec des $FF le restant de la piste
        while (out_pos < TRACK_SIZE)
            out[out_pos++] = (byte) (0xff);

        return out;
    }

    /*
     * Encode a 256-byte sector as SECTOR_SIZE disk bytes as follows:
     *
     *  40 sync bytes             : FF FF ...
     *   3 address header bytes   : D5 AA 96
     *   8 address block bytes
     *   3 address trailer bytes  : DE AA EB
     *   6 sync bytes             : FF FF FF FF FF FF
     *   3 data header bytes      : D5 AA AD
     * 343 data block bytes
     *   3 data trailer bytes     : DE AA EB
     * ===
     * 409 bytes         (409 * 16 sectors = $1990)
     */
    public static void nibblizeSector(int vol, int trk, int sector, byte in[],
            int in_ofs, byte out[], int i) {
        int loop, checksum, prev_value, value;
        int sector_buffer[] = new int[258];
        value = 0;

        /*
         * Step 1: write 40 sync bytes (0xff's).
         */
        for (loop = 0; loop < 40; loop++)
            out[i++] = (byte) 0xff;

        /*
         * Step 2: write the 3-byte address header (0xd5 0xaa 0x96).
         */
        out[i++] = (byte) 0xd5;
        out[i++] = (byte) 0xaa;
        out[i++] = (byte) 0x96;

        /*
         * Step 3: write the address block. Use 4-and-4 encoding to convert the
         * volume, track and sector and checksum into 2 disk bytes each. The
         * checksum is a simple exclusive OR of the first three values.
         */
        out[i++] = (byte) ((vol >> 1) | 0xaa);
        out[i++] = (byte) (vol | 0xaa);
        checksum = vol;
        out[i++] = (byte) ((trk >> 1) | 0xaa);
        out[i++] = (byte) (trk | 0xaa);
        checksum ^= trk;
        out[i++] = (byte) ((sector >> 1) | 0xaa);
        out[i++] = (byte) (sector | 0xaa);
        checksum ^= sector;
        out[i++] = (byte) ((checksum >> 1) | 0xaa);
        out[i++] = (byte) (checksum | 0xaa);

        /*
         * Step 4: write the 3-byte address trailer (0xde 0xaa 0xeb).
         */
        out[i++] = (byte) (0xde);
        out[i++] = (byte) (0xaa);
        out[i++] = (byte) (0xeb);

        /*
         * Step 5: write another 6 sync bytes.
         */
        for (loop = 0; loop < 6; loop++)
            out[i++] = (byte) (0xff);

        /*
         * Step 6: write the 3-byte data header.
         */
        out[i++] = (byte) (0xd5);
        out[i++] = (byte) (0xaa);
        out[i++] = (byte) (0xad);

        /*
         * Step 7: read the next 256-byte sector from the old disk image file,
         * and add two zero bytes to bring the number of bytes up to a multiple
         * of 3.
         */
        for (loop = 0; loop < 256; loop++)
            sector_buffer[loop] = in[loop + in_ofs] & 0xff;
        sector_buffer[256] = 0;
        sector_buffer[257] = 0;

        /*
         * Step 8: write the first 86 disk bytes of the data block, which
         * encodes the bottom two bits of each sector byte into six-bit values
         * as follows:
         *
         * disk byte n, bit 0 = sector byte n, bit 1 disk byte n, bit 1 = sector
         * byte n, bit 0 disk byte n, bit 2 = sector byte n + 86, bit 1 disk
         * byte n, bit 3 = sector byte n + 86, bit 0 disk byte n, bit 4 = sector
         * byte n + 172, bit 1 disk byte n, bit 5 = sector byte n + 172, bit 0
         *
         * The scheme allows each pair of bits to be shifted to the right out of
         * the disk byte, then shifted to the left into the sector byte.
         *
         * Before the 6-bit value is translated to a disk byte, it is exclusive
         * ORed with the previous 6-bit value, hence the values written are
         * really a running checksum.
         */
        prev_value = 0;
        for (loop = 0; loop < 86; loop++) {
            value = (sector_buffer[loop] & 0x01) << 1;
            value |= (sector_buffer[loop] & 0x02) >> 1;
            value |= (sector_buffer[loop + 86] & 0x01) << 3;
            value |= (sector_buffer[loop + 86] & 0x02) << 1;
            value |= (sector_buffer[loop + 172] & 0x01) << 5;
            value |= (sector_buffer[loop + 172] & 0x02) << 3;
            out[i++] = (byte) (byte_translation[value ^ prev_value]);
            prev_value = value;
        }

        /*
         * Step 9: write the last 256 disk bytes of the data block, which
         * encodes the top six bits of each sector byte. Again, each value is
         * exclusive ORed with the previous value to create a running checksum
         * (the first value is exclusive ORed with the last value of the
         * previous step).
         */

        for (loop = 0; loop < 256; loop++) {
            value = (sector_buffer[loop] >> 2);
            out[i++] = (byte) (byte_translation[value ^ prev_value]);
            prev_value = value;
        }

        /*
         * Step 10: write the last value as the checksum.
         */
        out[i++] = (byte) (byte_translation[value]);

        /*
         * Step 11: write the 3-byte data trailer.
         */
        out[i++] = (byte) (0xde);
        out[i++] = (byte) (0xaa);
        out[i++] = (byte) (0xeb);
       
    }

    // Normal byte (lower six bits only) -> disk byte translation table.
    static int byte_translation[] = {
            0x96, 0x97, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa6,
            0xa7, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb2, 0xb3,
            0xb4, 0xb5, 0xb6, 0xb7, 0xb9, 0xba, 0xbb, 0xbc,
            0xbd, 0xbe, 0xbf, 0xcb, 0xcd, 0xce, 0xcf, 0xd3,
            0xd6, 0xd7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde,
            0xdf, 0xe5, 0xe6, 0xe7, 0xe9, 0xea, 0xeb, 0xec,
            0xed, 0xee, 0xef, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
            0xf7, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };

    // Sector skewing table.
    static int skewing_table[] = {
        0, 7, 14, 6, 13, 5, 12, 4, 11, 3, 10, 2, 9, 1, 8, 15 };
   
}