******************************************************************************
**                                                                          **
*                   EXPLICATION DES ROUTINES DE SOUNDTRACK                   *
*                   Sources en assembleur et en GfA Basic                    *
**                                                                          **
******************************************************************************



Prliminaires
-------------

            Tout d'abord, vrifiez que vous possdez bien les fichiers
        suivants:

            - ROUTINES.TXT
            - EXEMPLE1.S
            - EXEMPLE2.S
            - REPLAY.S
            - COOKIE.S
            - GT2PLAYR.S
            - SNDKERNL.S
            - INST_KER.S
            - PLAYDSP.ASM
            - PLAYDSP.P56
            - REPLAY.PGT
            - EXEMPLE1.LST
            - GENEINCL.LST
            - PERTABLE.BIN
            - VEXP2LIN.BIN
            - VLIN2EXP.BIN
            - V_E2L_M.BIN

            S'il vous manque l'un des fichiers .BIN, .PGT ou .P56, ce n'est
        pas trs grave puisque ce sont des fichiers gnrs par les sources.
        En revanche, vous devez imprativement avoir les autres fichiers. Si
        ce n'est pas le cas, vous pouvez me les demander, en envoyant une
        disquette et un timbre pour le retour  cet adresse:

                        Laurent de SORAS
                        92 avenue Albert 1er
                        92500 Rueil-Malmaison
                        FRANCE

            Ces fichiers peuvent tre distribues librement, mais TOUS les
        fichiers cits ci-dessus doivent tre prsents. Si vous utilisez ces
        routines dans un but non lucratif, ce serait sympa de me le signaler,
        juste pour que je sois au courant de ce qui se fait. Par contre, si
        vous les utilisez dans un programme commercial, vous devez me demander
        mon autorisation.

            Ces routines permettent donc de rejouer des modules .GT2, issus du
        Graoumf Tracker. Le fichier dcrivant ce format est inclu dans ce
        logiciel, et si vous ne l'avez pas, vous pouvez toujours me commander
        la version dmo, toujours  la mme adresse.
            Mais elles perettent bien plus: le player est en fait constitu
        d'un "noyau", qui prend en charge les sons pour les jouer  la bonne
        frquence, les mixer, etc..., et du soundtracker proprement dit, qui
        s'occupe de grer la partition. Il est galement possible de mettre
        le noyau en rsident pour permettre  plusieurs applications de s'en
        servir, mme simultanment si c'est ncessaire.



Les diffrents sources
----------------------

            SNDKERNL.S est le source du noyau et GT2PLAYR.S celui du tracker.
        Bien videmment vous ne pouvez pas utiliser le tracker sans le noyau.
        Ces deux fichiers sont regroups par REPLAY.S qui va gnrer le
        fichier REPLAY.PGT, que vous pourrez utiliser dans vos programme,
        quelque soit le langage utilis. Il contient le tracker et le noyau
        non rsident.
            INST_KER.S gnre le programme d'installation du noyau en rsident
        (vous pouvez mettre INST_KER.PRG dans votre dossier AUTO). Il nces-
        site l'inclusion de SNDKERNL.S et COOKIE.S.
            EXEMPLE1.S et ~.LST sont des exemples d'utilisation du tracker
        avec noyau non rsident. ~.S ncessite SNDKERNEL.S et GT2PLAYR.S qui
        sont utiliss en Include tandis que ~.LST ncessite REPLAY.PGT, qui
        est charg au dbut du programme.
            EXEMPLE2.S est un exemple d'utilisation du noyau rsident. Ce
        source a besoin de COOKIE.S et de GT2PLAYR.S puisqu'il joue un sound-
        track. Le programme ne devra tre lanc qu'aprs INST_KER.PRG.
            Il y a galement tous les gnrateurs de tables etc. PLAYDSP.ASM
        est un source en code DSP qui doit gnrer PLAYDSP.P56 et GENEINCL.LST
        produit les 4 fichiers .BIN (tables de priodes et de volumes).



Schmas des inclusions
----------------------

        EXEMPLE1.S -+--- REPLAY.S -+--- SNDKERNL.S ----- PLAYDSP.P56
                    |              |
                    |              '--- GT2PLAYR.S -+--- PERTABLE.BIN
                    |                               +--- VEXP2LIN.BIN
                    |                               +--- VLIN2EXP.BIN
                    |                               '--- V_E2L_M.BIN
                    '--- *.GT2

        EXEMPLE2.S -+--- GT2PLAYR.S -+--- PERTABLE.BIN
                    |                +--- VEXP2LIN.BIN
                    |                +--- VLIN2EXP.BIN
                    |                '--- V_E2L_M.BIN
                    +--- COOKIE.S
                    '--- *.GT2

        INST_KER.S -+--- SNDKERNL.S ----- PLAYDSP.P56
                    |
                    '--- COOKIE.S

        EXEMPLE1.LST -+--- REPLAY.PGT
                      |
                      '--- *.GT2



Utilisation des routines en mode non rsident
---------------------------------------------

            Le noyau (ainsi que le tracker) fonctionne par un systme d'appel
        de fonctions. Elles sont documentes un peu plus loin dans ce texte.
        Cependant vous ne pouvez pas les utiliser n'importe comment. Voici la
        marche  suivre pour utiliser le noyau:
            * Activation du noyau
            * Rservation d'autant de voies que vous en avez besoin
            * Utilisation des voies prcdemment rserves, et UNIQUEMENT
              celles que vous avez rserves. Pour tous les samples utiliss,
              on devra avoir calcul un buffer de bouclage au pralable.
            * Libration des voies rserves
            * Dsactivation du noyau

            Pour le tracker, la marche  suivre est similaire:
            * Activation du noyau
            * Activation du player
                Pour chaque nouveau module:
                - Conversion du module au format interne (s'il ne l'est pas
                  dj)
                - Fabrication des buffers de bouclage
                - Lancement du module
                - Manipulations (pause, reprise, changement de position...)
                - Arrt du module
            * Dsactivation du player
            * Dsactivation du noyau

            Vous pouvez utiliser en mme temps le noyau pour le soundtrack ou
        pour vos prores samples. Si vous respectez correctement les processus
        dcrit ci-dessus, vous n'aurez pas de conflits de voies ou autres
        problmes. Si a n'est pas clair, regardez les fonctions et surtout
        les sources d'exemple.
            Aprs chaque opration, testez si une erreur s'est produite et
        prvoyez comment agir en consquence. On n'est jamais  l'abris d'un
        Sound Sub-System occup ou d'un module erron.
            A propos des samples, ils doivent tous avoir un buffer de bou-
        clage, mme s'ils ne sont pas boucls. Une fonction s'occupe du
        calcul, mais vous devez prvoir 1 Kb par sample. Pour les modules,
        tous les buffers sont calculs en mme temps. Si vous changez l'adres-
        se de votre module entre temps (avant le replay), n'oubliez pas de
        signaler le changement en demandant les adresses calcules prcdem-
        ment puis en les renvoyant aprs les avoir reloges.

            Les fonctions seront appeles en dposant les paramtres 
        l'envers sur la pile (comme d'habitude en C) puis en effectuant un
        saut  l'adresse avec un Bsr. Le registre d0 recevra le rsultat. Les
        erreurs sont signales par un mot long ngatif. Les routines du noyau
        doivent tre prcdes de "gtkr_", et de "gtkpl_" pour les routines du
        soundtracker.
            Pour les programmeurs en GfA Basic, il faut faire des appels de
        la forme :

            Resultat% = C:routine%( w:numro, ?:para1, ?:para2, ...paraN)

            O routine% est l'adresse de la bibliothque de routines, numro
        est le numro de la fonction appele, para1,...N les paramtres, dans
        l'ordre cette fois-ci, et ?: le format de chaque paramtre (W: pour un
        mot simple, L: pour un mot long). Il faut Faire bien attention  ne
        pas oublier ce dernier point.            

            Au point de vue les labels, tous les labels du noyaux sont pr-
        cds de "gtkr_". Ceux du soundtrackers sont prcds de "gtkpl_" ou
        de "fx_". Les diffrentes structures utilises se terminent par "_t",
        "_s", "_i", "_p" ou commencent par "adr_" et "mod_"



Utilisation des routines en mode rsident
-----------------------------------------

            La marche  suivre est identique au mode non rsident,  part pour
        l'appel, qui ne se fait plus avec des Bsr mais avec des Trap #8. Il
        suffit d'empiler le numro de fonction aprs les paramtres, comme
        pour un vulgaire appel systme.
            Vous devrez tester au dbut de votre programme si le noyau est
        bien en mmoire (il dpose le cookie "SKER"), et s'il est dj actif.
        Il est possible que d'autres applications l'utilisent, donc faites
        bien attention  la rservation des pistes, combien sont disponibles,
        etc.
            De mme en partant, vous ne devez dsactiver le noyau que si plus
        personne ne l'utilise. Mais ce n'est pas une raison pour le laisser
        activ en permanence car le systme sonore du Falcon serait bloqu
        inutilement.

            Voici une faon typique d'utiliser le noyau en mode rsident:
            * Tester si le noyau est l grce au cookie "SKER", l'installer si
              besoin est.
            * Activer le noyau s'il n'est pas actif.
            * Tester si le nombre de voies disponibles est suffisant.
            * Dposer si vous voulez un identificateur d'application (voir
              plus bas).
            * Rserver le nombre de voies ncessaires  l'application
            * Utilisation des voies prcdemment rserves, et UNIQUEMENT
              celles que vous avez rserves. Pour tous les samples utiliss,
              on devra avoir calcul un buffer de bouclage au pralable.
            * Libration des voies rserves.
            * Retirer l'identificateur d'application si vous en aviez dpos
              un.
            * Optionnel: dsactivation du noyau. Tester d'abord si d'autres
              applications utilisent le noyau, en comparant le nombre de voies
              libres et le nombre total de voies, puis en regardant le nombre
              d'identificateurs. Si le noyau est totalement libre, on peut le
              dsactiver.

            Les identificateurs d'applications sont comme les cookies, ils
        permettent de savoir si tel ou tel programme utilise le noyau. Chaque
        identificateur est suivi d'une valeur propre  l'application. Elle
        pourra par exemple contenir l'adresse d'un bloc de donnes servant 
        un protocole inter-application, ou contenant diffrentes informations
        sur le programme.





**
*                                                                            *
*       DESCRIPTION DES FONCTIONS DE CONTROLE DU NOYAU SONORE                *
*                                                                            *
**

------------------------------------------------------------------------------
$001    kernel_status

            Demande si le noyau est install. Renvoie 0 s'il ne l'est pas.

------------------------------------------------------------------------------
$002    kernel_on (nbrtrack.w, adrbloc.l)

            Installe le noyau. Nbrtrack indique le nombre de voies  grer
        (maximum 32 normalement). Adrbloc est l'adresse du bloc des informa-
        tions sur les voies. Chaque voie prend au plus 256 octets.
            Retourne -1 si le noyau tait dj install, et 0 s'il n'y a pas
        eu d'erreur.

------------------------------------------------------------------------------
$003    kernel_off

            Dsinstalle le noyau. Renvoie -1 si le noyau n'tait pas install,
        0 sinon.

------------------------------------------------------------------------------
$004    reset_kernel_tracks

            Effectue le reset de toutes le voies du noyau, arrte donc tous
        les sons en cours de replay.

------------------------------------------------------------------------------
$005    reserve_track (id.w)

            Rserve une piste. Id.w correspond a un indicateur que l'utilisa-
        teur peut attribuer  sa piste. $FFFF correspond  aucune identifica-
        tion particulire.
            Le numro.w de la voie rserve est alors renvoy. L'utilisateur
        ne pourra utiliser que des voies rserves, il faut donc conserver ce
        numro. Si -1 est renvoy, c'est qu'il n'y avait plus de voie disponi-
        ble.

------------------------------------------------------------------------------
$006    free_track

            C'est l'inverse de la fonction prcdente, elle libre une voie
        qui a t rserve au paravant.

------------------------------------------------------------------------------
$007    make_rbuffer (adrspl.l, adrbuf.l, length.l, reppos.l, replen.l,
                      resol.w)

            Fabrique un buffer de rptition pour un sample. Chaque sample
        doit avoir un buffer de bouclage, mme ceux qui ne sont pas boucls.
        Adrspl est l'adresse du sample, adrbuf l'adresse du buffer, qui fait
        1024 octets. Length est la longueur du sample, reppos la position de
        rptition et replen la longueur de la boucle, tout a PAIR et en
        OCTETS. Un sample non boucl devra avoir reppos = 0 et replen = 2.
        Resol est la rsolution du sample (1 = 8 bits, 2 = 16 bits).

------------------------------------------------------------------------------
$008    play_sample (track.w, adrspl.l, lonspl.l, posspl.l, volume.w,
                     balance.w, freq.w, resol.w, flags.w, adrbuf.l
                     [, reppos.l, replen.l] )

            Joue un sample. Si la voie est en pause, elle repasse automatique-
        ment en marche. Les valeurs entre parenthses sont les valeurs qui ne
        modifient pas les paramtres qu'elles concernent. D'autre part, toutes
        les longueurs et adresses sont paires et en octets.
            - Track indique la piste sur laquelle le sample doit tre jou.
            - Adrspl (-1) est l'adresse du sample,
            - lonspl (-1) sa longueur, qui est en fait ignore si le sample
              est boucl.
            - Posspl (-1) est la position de dpart dans le sample (pour
              commencer  le jouer  partir du milieu par exemple).
            - Volume (-1) est son volume (0..$800) et
            - balance (-1) sa position panoramique dans l'espace
              (0..$800..$FFF).
            - Freq (0) est la frquence d'chantillonnage du sample, en Hz.
            - Resol (-1) est la rsolution du sample (1 = 8 bits, 2 = 16 bits)
            - Flags contient 2 indicateurs : le bit 0 s'il est mis demande 
              ce que le sample soit boucl, et le bit 1 demande le calcul du
              buffer de bouclage avant le replay, si celui-ci n'a pas dj t
              effectu.
            - Adrbuf (-1) en est son adresse.
            Si le bit 0 de flag est mis, il y a deux autres paramtres :
            - reppos qui est la position de rptition, et
            - replen qui est la longueur de la boucle. Ces paramtres sont
              ignors si le bit 0 est nul.

------------------------------------------------------------------------------
$009    stop_track (track.w)

            Arrte une voie et effectue son reset, sans cependant la librer.

------------------------------------------------------------------------------
$00A    pause_track (track.w)

            Met une voie en pause. Son tat est suspendu jusqu' ce qu'on lui
        ordonne de reprendre.

------------------------------------------------------------------------------
$00B    cont_track (track.w)

            Reprise d'une voie mise en pause.

------------------------------------------------------------------------------
$00C    add_routine (adrrout.l)

            Ajoute une routine dans le noyau, adrrout est son adresse. Renvoie
        le nombre de fois qu'est prsente cette routine dans le noyau. Cette
        routine sera appele  chaque interruption venant du DSP, c'est  dire
        environ toutes les 50mes de seconde (mais cette priode peut tre
        modifie).

------------------------------------------------------------------------------
$00D    remove_routine (adrrout.l)

            Enlve une routine du noyau. Si elle tait l plusieurs fois, elle
        n'est retire qu'une fois. Si elle n'a pas t trouve, -1 est
        renvoy.

------------------------------------------------------------------------------
$00E    get_master_vol

            Renvoie le Master volume.

------------------------------------------------------------------------------
$00F    set_master_vol (master.w)

            Fixe le nouveau Master volume (0-$1000). Plus le nombre de voies
        est lev, plus celui-ci doit tre faible pour viter les risques de
        saturation. En gnral, on le fixe  4096 / nbrvoies, mais en gnral
        12288 / (nbrvoies + 4) convient.

------------------------------------------------------------------------------
$010    get_vblsize

            Renvoie le nombre d'chantillons envoys par pseudo-vbl.

------------------------------------------------------------------------------
$011    set_vblsize (nbr.w)

            Fixe le nouveau nombre d'chantillons envoys par pseudo-vbl.
        Cette valeur peut tre entre 100 et 1200, mais 983 est une valeur
        moyenne qui correspond  des interruptions de 50 Hz pour une frquence
        de replay de 49.17 KHz.

------------------------------------------------------------------------------
$012    get_track_adr

            Demande l'adresse des informations sur les voies (en fait celle
        qui a t communique  l'initialisation du noyau). Ceci permet de
        modifier directement l'tat de chaque voies sans passer par les
        routines.

------------------------------------------------------------------------------
$013    set_track_adr (adr.l)

            Fixe la nouvelle adresse des infos sur les voies. Cette adresse ne
        doit tre modifie que si une seule application utilise le noyau lors
        de cette opration, c.a.d s'il n'y a aucune voie rserve, ou
        seulement par l'application en question. Lorsque l'app se termine,
        elle doit restituer l'ancienne adresse, toujours dans les mmes condi-
        tions, ou laisser l'espace mmoire rserv. Retourne l'ancienne
        adresse.

------------------------------------------------------------------------------
$014    get_replay_freq

            Renvoie la frquence de replay du player, en Hz.

------------------------------------------------------------------------------
$015    set_replay_freq (prediv.w)

            Change la frquence de restitution du noyau. Cette routine peut
        tre appele alors que le noyau est dsactiv. Attention, la taille
        d'une pseudo-vbl n'est pas recalcule. Prediv est le prdiviseur de
        l'horloge du CoDec. Les valeurs normalement autorises sont 1, 2, 3,
        4, 5, 7, 9 et 11, correspondant aux frquences  49170, 32780, 24585,
        19668, 16390, 12292, 9834 et 8195 Hz.
            Renvoie l'erreur -1 si le prdiviseur n'est pas compris entre 1 et
        15 (inclus).

------------------------------------------------------------------------------
$016    total_nbr_of_tracks

            Renvoie le nombre total de voies du noyau.

------------------------------------------------------------------------------
$017    nbr_of_free_tracks

            Renvoie le nombre de voies libres.

------------------------------------------------------------------------------
$018    put_new_app_id (ident.l, value.l)

            Insre un identificateur d'application dans le noyau. Cet identi-
        ficateur sert surtout, quand le noyau est rsident,  sigaler la
        prsence de telle application  telle autre, comme les cookies du
        systme. L'identificateur doit tre suivi d'une valeur sur un mot
        long, contenant des informations propres  l'application, comme par
        exemple l'adresse d'une table de donnes servant  un protocole de
        communication inter-application.
            Renvoie 0 si tout s'est pass correctement, 1 si l'identificateur
        tait dj l (il est cependant rinstall), et -1 s'il n'y a plus de
        place sur la table des identificateurs (cela ne devrait normalement
        pas se produire).
            
------------------------------------------------------------------------------
$019    get_app_id (ident.l)

            Demande si l'identificateur ident est prsent sur le noyau. S'il
        ne l'est pas, 0 est renvoy. S'il l'est, une adresse pointant sur
        l'identificateur suivi de sa valeur est renvoye. Il faudra alors
        chercher immdiatement la valeur de l'id, car l'adresse peut bouger
        (comme pour les cookies).
------------------------------------------------------------------------------
$01A    remove_app_id (ident.l)

            Enlve l'identificateur de la table. Si celui-ci n'tait pas l,
        renvoie -1. Si l'id tait le seul, renvoie 1. Sinon renvoie 0.

------------------------------------------------------------------------------
$01B    nbr_of_app_id

            Renvoie le nombre d'identificateurs d'application prsents sur la
        table.

------------------------------------------------------------------------------
$01C    interpolate_track (track.w, state.w)

            Interpole une piste, ce qui augmente la qualit des samples en
        basse frquence, mais prend beaucoup plus de temps machine (pour le
        DSP). Track reprsente le numro de piste, et state l'tat: 0 pour
        ne pas avoir d'interpolation (par dfaut), et n'importe quel autre
        nombre pour activer l'interpolation.

------------------------------------------------------------------------------



**
*                                                                            *
*       DESCRIPTION DES FONCTIONS DE CONTROLE DU SOUNDTRACKER                *
*                                                                            *
**

            Pour utiliser ces routines, le noyau doit tre install.

------------------------------------------------------------------------------
$102    player_on

            Installe le soundtracker. Renvoie 0 si pas d'erreur, -1 si le
        player tait dj install et -2 s'il n'y a plus de voies disponibles.

------------------------------------------------------------------------------
$103    player_off

            Dsinstalle le soundtracker. Renvoie -1 si le soundtracker n'tait
        pas encore install.

------------------------------------------------------------------------------
$104    reset_sndtrk_tracks

            Reset de toutes les pistes du soundtrack

------------------------------------------------------------------------------
$105    convert_module (type.w, adrmod.l, adrconv.l)

            Convertit un module GT2 de type quelconque en un module GT2
        jouable par la routine. Il s'agit en fait de convertir les versions
        infrieures  3 en version 3, et pour des versions suprieures, de
        dcompacter ventuellement les patterns, samples, etc. (ce seront des
        amliorations futures). Ici, type vaut toujours 0. Adrmod est l'adres-
        se du module  convertir et adrconv l'adresse du module converti. Ces
        deux adresses peuvent tre identiques pour effectuer une conversion
        "sur place". Attention tout de mme, le module converti va prendre
        plus de place. Prvoir large, et rduire si ncessaire l'espace avec
        la taille du nouveau module qui est renvoye par la fonction.
            Si le type du module n'est pas reconnu (C..d diffrent de 0), la
        fonction retourne -1. Si le module n'est pas un GT2, elle retourne -4.
            Tout module doit tre converti avant d'tre jou.

------------------------------------------------------------------------------
$106    make_rb_module (adrmod.l, adrbuf.l, adradrbuf.l)

            Effectue le bouclage de tous les samples d'un module au format
        interne. Adrmod est l'adresse du module, adrbuf est l'adresse d'une
        zone pour les buffers (256Ko maxi) et adradrbuf est l'adresse d'un
        tableau de 256 mots longs destin  contenir les adresses des buffers.
        Si cette adresse est nulle, les buffers sont directement assigns au
        module en cours de replay, ainsi que les adresses des samples

------------------------------------------------------------------------------
$107    get_adr_samples (ptr.l)

            Demande les adresses des samples et de leurs buffers de bouclage
        du module en cours. Ptr pointe sur une zone de 2048 octets contenant
        les 256 adresses des samples puis les 256 adresses des buffers. Cette
        zone commence avec sample numro 0.

------------------------------------------------------------------------------
$108    set_adr_samples (ptr.l)

            Fixe toutes les adresses des samples et de leurs buffers de
        bouclage pour le module en cours. Ptr pointe sur une zone de 2048
        octets contenant les 256 adresses des samples puis les 256 adresses
        des buffers. Si une adresse est nulle, elle n'est pas modifie.

------------------------------------------------------------------------------
$109    new_module (adrmod.l, adrrep.l, songpos.w, linepos.w)

            Initialise un module au format interne et commence le replay.
        Adrmod est l'adresse du module, adrrep est l'adresses des buffers
        de rptitions destins  tre calculs (1 Ko/sample, 256 samples
        maximum).
        Si cette adresse est nulle, rien n'est chang.
            Songpos et linepos sont respectivement les positions et lignes de
        dpart du replay.
            La fonction renvoie -1 si le module n'tait pas au format interne
        et -2 s'il n'y avait pas assez de voies disponibles.

------------------------------------------------------------------------------
$10A    stop_module

            Arrte de jouer le module en cours. Un nouveau module devra tre
        rinitialis si on veut jouer quelque chose aprs.

------------------------------------------------------------------------------
$10B    pause_module

            Met le module en pause. Renvoie -1 si on tait dj en pause.

------------------------------------------------------------------------------
$10C    cont_module

            Reprend un module en pause. Renvoie -1 si on n'tait pas en pause.


------------------------------------------------------------------------------
$10D    change_modpos (songpos.w, linepos.w)

            Change la position de replay d'un module. Songpos et linepos sont
        respectivement la nouvelle position et la nouvelle ligne de replay.
        Renvoie -1 si la position est hors song, -2 si le numro de ligne est
        hors pattern.

------------------------------------------------------------------------------
$10E    get_modsongpos

            Renvoie le numro de la position qui est joue actuellement dans
        le module.

------------------------------------------------------------------------------
$10F    get_modlinepos

            Renvoie le numro de ligne de pattern qui est joue actuellement
        dans le module.

------------------------------------------------------------------------------
$110    get_tempo

            Renvoie le tempo du module

------------------------------------------------------------------------------
$111    set_tempo (tempo.w)

            Permet de fixer un nouveau tempo au module.

------------------------------------------------------------------------------
$112    get_synchro_adr

            Demande l'adresse du flag de synchronisation pour les dmos. Ce
        flag est un mot, qui est chang par l'effet B9xx.

------------------------------------------------------------------------------



Mes A coulent pas: bugs de l'ancien player (de .GTK)
----------------------------------------------------

    Pour ceux qui utiliseraient les anciennes routines et qui ne peuvent pas,
ou ne veulent pas passer aux nouvelles routines, voici une liste de bugs trs
gnants que vous pouvez corriger:
    - Dans la fonction grtk_pause_module, il y a une erreur dans la ligne sous
le label .wait2: transformez "bne.s .wait" en "bne.s .wait2". Ce bug provo-
quait un bloquage du programme, mais passait inaperu sous debugger.
    - Dans la fonction gtkr_stop_module, il y a un problme de registres
d'adresse aux lignes "lea gtkpl_num_track+2,a0" et "move.w (a0)+,-(sp)".
Remplacez les "a0" par "a2". Ce bug ne stopait pas tout le temps le module!
    - Dans la routine gtkr_kernel_interruption,  la fin de la routine d'envoi
de samples 16 bits (juste avant la ligne "Rchantillonnage au 030 ..."), il
manque un "bra sendsam_next". Ce bug provoquait un plantage lors du replay de
samples 16 bits.
    - La fonction gtkr_add_routine marche mais renvoie n'importe quoi...
