home *** CD-ROM | disk | FTP | other *** search
/ Supremacy 1 / Supremacy-1.iso / DEMOS / C-D / DNTPAP4.ZIP / ARCHIVES.DNT / SOURCES.ZIP / BLITZ_24 / BLITZ_24.S < prev   
Encoding:
Text File  |  1992-12-07  |  45.7 KB  |  1,752 lines
  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;
  3. ;Programme de convertions d'images 24 bits au format RAW ou TGA
  4. ;pour STE et STF avec blitter.
  5. ;Le fichier image crée par ce convertisseur est .BIM
  6. ;Il comporte le bloc de palettes (=(48+7)*199*4 octets) et le bloc images
  7. ;(deux écrans 64000 octets) soit au total 107780 octets (packing is good
  8. ;for you...)
  9. ;C'est énorme, mais je signale que compacté ou non, c'est plus petit que
  10. ;l'original...
  11. ;
  12. ;(C)oderight Nullos//DNT-Crew 1992...
  13. ;
  14. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  15.     OPT    O+,W-    ;Optimisations, pas de Warnings
  16.  
  17. start    move.l    4(sp),a0        ;
  18.     lea    stackup,sp        ;
  19.     movea.l    $0c(a0),a1        ;Text
  20.     adda.l    $14(a0),a1        ;    +Data
  21.     adda.l    $1c(a0),a1        ;         +Bss
  22.     lea    256(a1),a1        ;             +BasePage
  23.     movem.l    a0-a1,-(sp)    ;Taille à réserver, donc
  24.     clr.w    -(sp)        ;
  25.     move.w    #$4a,-(sp)        ;
  26.     trap    #1        ;
  27.     lea    12(sp),sp        ;
  28.     bsr    Appl_Init        ;Initialise l'AES
  29.     lea    InfoDis1,a0    ;Une petite pub...
  30.     bsr    Form_Alert        ;hop-là
  31.     lea    InfoDis2,a0    ;
  32.     bsr    Form_Alert        ;
  33.  
  34.     move.l    #scr_buf+256,d0    ;Initialise les écrans
  35.     clr.b    d0        ;
  36.     move.l    d0,ecran        ;
  37.     addi.l    #32000,d0        ;
  38.     move.l    d0,ecran+4        ;
  39.     bsr    Antiparasite_Convert_x;x->palette déparasitée
  40.     bsr    Precalc_Screen_x    ;x->plot
  41.     pea    Test_STE        ;détecte STE/STF+blitter
  42.     move.w    #38,-(sp)        ;routine superviseur
  43.     trap    #14        ;
  44.     addq.l    #6,sp        ;
  45.     tst.w    Work_x        ;Test correct ?
  46.     beq.s    .Ok_man        ;ouaip
  47.     lea    Bliterr,a0        ;pas de blitter !
  48.     bsr    Form_Alert        ;
  49.     bra    Appl_Exit        ;finito
  50.     
  51.  
  52. .Ok_man    lea    path,a2        ;Construit le chemin par défaut
  53.     move.w    #$19,-(sp)        ;Demande le lecteur courant
  54.     trap    #1        ;
  55.     addi.b    #"A",d0        ;transformé en ASCII
  56.     move.b    d0,(a2)+        ;
  57.     move.b    #":",(a2)+        ;
  58.     clr.w    -(sp)        ;Demande au Gemdos le chemin
  59.     move.l    a2,-(sp)        ;d'accès du lecteur courant
  60.     move.w    #$47,-(sp)        ;
  61.     trap    #1        ;
  62.     lea    10(sp),sp        ;rétablit la pile
  63. .pathend    tst.b    (a2)+        ;cherche la fin du chemin
  64.     bne.s    .pathend        ;
  65.     subq.l    #1,a2        ;corrige le ()+
  66.     move.b    #"\",(a2)+        ;Pose le masque juste derrière
  67.     move.b    #"*",(a2)+        ;*.*=tous les fichiers.
  68.     move.b    #".",(a2)+        ;
  69.     move.b    #"*",(a2)+        ;
  70.     clr.b    (a2)+        ;
  71.     clr.b    name        ;pas encore de nom
  72.     move.w    #13,entrelace    ;entrelacement par défaut
  73.  
  74. MasterBcl    lea    path,a0        ;chemin d'accès+*.*
  75.     lea    name,a1        ;nom du dernier fichier
  76.     lea    filename,a2    ;adresse de retour
  77.     bsr    FileSelect        ;go!
  78.     beq    .MB_end        ;Si problème..
  79.     lea    KelForm,a0        ;RAW ou TGA ?
  80.     bsr    Form_Alert        ;
  81.     subq.w    #1,d0        ;0=RAW 1=TGA 2=BIM
  82.     move.w    d0,imtype        ;
  83.     subq.w    #2,d0        ;
  84.     beq    .AffichBIM        ;Affichage simple ?
  85.     lea    ConvTyp,a0        ;Demande des infos..
  86.     bsr    Form_Alert        ;
  87.     subq.w    #2,d0        ;cf paramètres de convertion
  88.     move.w    d0,flickflag    ;
  89.  
  90. .MB_0    lea    ConvNum,a0        ;facteur d'entrelacement
  91.     bsr    Form_Alert        ;hop
  92.     subq.w    #2,d0        ;
  93.     beq.s    .MB_2        ;ok,choix effectué
  94.     add.w    entrelace,d0    ;+ ou -1
  95.     cmpi.w    #100,d0        ;Faut pas déconner non plus..
  96.     blt.s    *+4        ;
  97.     moveq    #99,d0        ;
  98.     cmpi.w    #-100,d0        ;
  99.     bgt.s    *+4        ;
  100.     moveq    #-99,d0        ;
  101.     moveq    #"+",d1        ;nombre positif
  102.     andi.l    #$0000ffff,d0    ;annule bits 16-31
  103.     move.w    d0,entrelace    ;yoplaboum
  104.     bpl.s    *+6        ;
  105.     moveq    #"-",d1        ;ah non, négatif !
  106.     neg.w    d0        ;
  107.     lea    _CN_str+3,a0    ;sort le nouveau nombre..
  108.     moveq    #1,d2        ;deux chiffres.
  109. .MB_1    divu    #10,d0        ;hop
  110.     swap    d0        ;
  111.     addi.w    #"0",d0        ;
  112.     move.b    d0,-(a0)        ;
  113.     clr.w    d0        ;
  114.     swap    d0        ;
  115.     dbf    d2,.MB_1        ;
  116.     move.b    d1,-(a0)        ;
  117.     bra.s    .MB_0        ;
  118.  
  119. .MB_2    lea    ConvHtz,a0        ;Quelle fréquence ?
  120.     bsr    Form_Alert        ;
  121.     subq.w    #1,d0        ;
  122.     add.w    d0,d0        ;
  123.     move.b    d0,specsync    ;
  124.     bsr    Load_Image        ;On procède au chargement
  125.     beq    .MB_end        ;en cas d'erreur
  126.     move.l    a0,image        ;conserve adresse image
  127.  
  128.     clr.l    -(sp)        ;Superviseur
  129.     move.w    #$20,-(sp)        ;
  130.     trap    #1        ;
  131.     move.l    d0,2(sp)        ;
  132.     bsr    InitHard        ;Initialisation Hardware
  133.     move.l    #DummyVBL,$70.w    ;du ST
  134.     move.l    ecran,d0        ;On montre ce qui se
  135.     lsr.w    #8,d0        ;passe à l'écran
  136.     move.l    d0,$ffff8200.w    ;pour patienter...
  137.  
  138.     movea.l    image,a0        ;
  139.     movea.l    ecran,a1        ;
  140.     lea    pal_buf,a2        ;
  141.     move.w    flickflag,d0    ;
  142.     move.w    entrelace,d1    ;
  143.     move.w    imtype,d2        ;
  144.     bsr    Convert_24Bits    ;Convertion proprement dite
  145.  
  146. .MB_aff    clr.w    flickflag        ;indicateur de swap
  147.     stop    #$2300        ;synchro vbl
  148. .sync_bcl    stop    #$2300        ;
  149.     move.b    specsync,$ffff820a.w    ;passage en 50/60 Hz
  150.     movem.l    ecran,d0-d1    ;swap écran
  151.     exg.l    d0,d1        ;
  152.     movem.l    d0-d1,ecran    ;
  153.     lsr.w    #8,d1        ;mise à jour de l'adresse
  154.     move.l    d1,$ffff8200.w    ;écran
  155.     lea    BLIT_base.w,a0    ;Paramètre le blitter
  156.     move.w    #2,b_dst_xinc(a0)    ;couleurs par couleurs,puis
  157.     move.w    #-30,b_dst_yinc(a0)    ;retour en début de palette
  158.     move.l    #-1,b_mask1(a0)    ;pas de masquage
  159.     move.w    #-1,b_mask3(a0)    ;
  160.     move.w    #2,b_src_xinc(a0)    ;tout le bloc de palettes
  161.     move.w    #2,b_src_yinc(a0)    ;à la fois
  162.     move.b    #2,b_hop(a0)    ;aucune opérations logique
  163.     move.b    #3,b_op(a0)    ;
  164.     clr.b    b_mode(a0)        ;pas de décalage
  165.     movem.l    palette,a4-a5    ;swap des palettes
  166.     exg.l    a4,a5        ;
  167.     movem.l    a4-a5,palette    ;
  168.     lea    7*199*2(a4),a5    ;a4=palettes de bordure
  169.     move.l    a5,b_src_adr(a0)    ;a5=palettes centrales
  170.     move.l    #v_color0,b_dst_adr(a0);
  171.     move.w    #16,b_x_count(a0)    ;16 couleurs par palettes
  172.     tst.b    specsync        ;selon la synchro
  173.     bne.s    *+8        ;
  174.     bsr.w    Spec_60Hz        ;
  175.     bra.s    *+6        ;
  176.     bsr.w    Spec_50Hz        ;
  177.  
  178.     not.w    flickflag        ;couple d'images affichées?
  179.     bne    .sync_bcl        ;non (il faut un nombre
  180.     cmpi.b    #$39,$fffffc02.w    ;pair de swapping...)
  181.     bne    .sync_bcl        ;Barre espace ?
  182.     bsr    ExitHard        ;restituer le ST
  183.     trap    #1        ;repasse en utilisateur
  184.     addq.l    #6,sp        ;
  185.     
  186.     subq.w    #2,imtype        ;image BIM ?
  187.     beq.s    .MB_3        ;alors pas besoin de sauver!
  188.     lea    SavePic,a0        ;Sauvegarder l'image ?
  189.     bsr    Form_Alert        ;
  190.     subq.w    #1,d0        ;
  191.     bne.s    .MB_3        ;
  192.     lea    path,a0        ;chemin d'accès+*.*
  193.     lea    name,a1        ;nom du dernier fichier
  194.     lea    filename,a2    ;adresse de retour
  195.     bsr    FileSelect        ;go!
  196.     beq    .MB_2        ;Si problème..
  197.     bsr    Save_Image        ;sinon,let's go
  198.     
  199. .MB_3    move.l    image,-(sp)    ;libère la mémoire
  200.     move.w    #$49,-(sp)        ;de l'image
  201.     trap    #1        ;
  202.     addq.l    #6,sp        ;
  203.  
  204. .MB_end    lea    NextOne,a0        ;
  205.     bsr    Form_Alert        ;une autre ?
  206.     subq.w    #1,d0        ;
  207.     beq    MasterBcl        ;
  208.     bra    Appl_Exit        ;
  209.  
  210.  
  211. .AffichBIM                ;Affichage d'un fichier BIM
  212.     lea    ConvHtz,a0        ;Quelle fréquence ?
  213.     bsr    Form_Alert        ;
  214.     subq.w    #1,d0        ;
  215.     add.w    d0,d0        ;
  216.     move.b    d0,specsync    ;
  217.     bsr    Load_Image        ;charge le fichier
  218.     beq.s    .MB_end        ;en cas de problèmes
  219.     move.l    a0,image        ;
  220.     lea    pal_buf,a1        ;recopie les palettes
  221.     move.w    #(48+7)*199-1,d0    ;
  222. .AB_0    move.l    (a0)+,(a1)+    ;hop!
  223.     dbf    d0,.AB_0        ;
  224.     move.l    ecran,a1        ;puis les écrans
  225.     move.w    #7999,d0        ;
  226. .AB_1    move.l    (a0)+,(a1)+    ;
  227.     move.l    (a0)+,(a1)+    ;
  228.     dbf    d0,.AB_1        ;
  229.     clr.l    -(sp)        ;Superviseur
  230.     move.w    #$20,-(sp)        ;
  231.     trap    #1        ;
  232.     move.l    d0,2(sp)        ;
  233.     bsr    InitHard        ;Initialisation Hardware
  234.     move.l    #DummyVBL,$70.w    ;du ST
  235.     bra    .MB_aff        ;et maintenant,affiche
  236. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  237. ;Détermine le type de machines
  238. Test_STE    movem.l    d0/a0,-(sp)    ;
  239.     lea    $5a0.w,a0        ;Cookie jar
  240.     move.l    (a0),d0        ;
  241.     beq.s    .TS_blit        ;STF, test le blitter
  242.     movea.l    d0,a0        ;
  243. .TS_0    move.l    (a0)+,d0        ;
  244.     beq.s    .TS_blit        ;Fin du cookie-jar ?
  245.     cmpi.l    #"_VDO",d0        ;Type de shifter vidéo ?
  246.     beq.s    .TS_1        ;oui
  247.     addq.l    #4,a0        ;
  248.     bra.s    .TS_0        ;
  249. .TS_1    tst.w    (a0)        ;Alors, STF ou STE ?
  250.     beq.s    .TS_blit        ;si nul, alors STF
  251.     move.l    #Convert_STE,Convert_rgb;sinon, STE=> table kivabien
  252. .TS_blit    movea.l    $8.w,a0        ;Test la présence du blitter
  253.     movea.l    sp,a1        ;sauve la pile
  254.     move.l    #.TS_noblit,$8.w    ;erreur de bus détournée
  255.     move.w    #-1,Work_x        ;pas de blitter par défaut
  256.     tst.b    b_ctrl+BLIT_base.w    ;tentative d'accès
  257.     clr.w    Work_x        ;y'en a un !!
  258. .TS_noblit    move.l    a0,$8.w        ;
  259.     movea.l    a1,sp        ;
  260.     move.l    (sp)+,d0        ;
  261.     movea.l    (sp)+,a0        ;
  262.     rts            ;
  263. ;A ma connaissance, il n'y a pas de moyen de savoir si le blitter est
  264. ;présent sans avoir à tester soi-même. Pour cela, on détourne l'erreur
  265. ;de bus ($8.w). Puis on fait une tentative d'accès blitter. Si il
  266. ;y en a un, tout se passe bien, l'instruction Work_x est éxécutée,
  267. ;sinon il y a une erreur de bus, et on se retrouve directement
  268. ;sur .TS_noblit . C'est pas très poétique, mais ca marche.
  269. ;
  270. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  271. ;;;;;;;;;;;; Routines d'affichage des images ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  272. ;;;;;  En entrée ...                      ;;;;;
  273. ;A0=adresse blitter   A4=couleurs bordure
  274. ;Le blitter doit avoir été préparé au transfert...
  275. ;
  276. ;;;;;  Pendant les routines qui suivent.. ;;;;;
  277. ;A0=adresse y_count.  D0=nb_pal/ligne=3 (blitter)
  278. ;A1=adresse b_ctrl    D1=lancement du blitter
  279. ;A2=adresse couleur 0 pour bordure noire     D2=0
  280. ;A3=adresse    "    9        "
  281. ;A4=couleurs complémentaires de la bordure
  282. ;A5=travail sur le transferts de bordure
  283. ;D3=Nombre-1 de lignes à afficher
  284. ;(ces registres sont initialisés plus bas)
  285. ;;;;;  Synchronisation écran 50Hz         ;;;;;
  286. Spec_50Hz
  287.     move.b    v_count_l.w,d0
  288.     beq.s    *-4
  289.     neg.b    d0
  290.     ror.l    d0,d0
  291.     moveq    #4,d0
  292.     ror.l    d0,d0
  293.     moveq    #62,d0
  294.     ror.l    d0,d0
  295. ;;;;;  Chargement des registres           ;;;;;
  296.     moveq    #$03,d0
  297.     moveq    #$c0,d1
  298.     moveq    #$00,d2
  299.     move.w    #198,d3
  300.     lea    b_ctrl(a0),a1
  301.     lea    b_y_count(a0),a0
  302.     lea    v_color0.w,a2
  303.     lea    v_color9.w,a3
  304. ;;;;;  Lancement du transfert de couleurs ;;;;;
  305. .line_bcl    movea.l    a3,a5
  306.     move.l    (a4)+,(a5)+
  307.     move.l    (a4)+,(a5)+
  308.     move.l    (a4)+,(a5)+
  309.     move.w    (a4)+,(a5)+
  310.     move.w    d0,(a0)
  311.     move.b    d1,(a1)
  312.     move.w    d2,(a2)
  313.     nop
  314.     nop
  315.     dbf    d3,.line_bcl
  316.     bra.s    Spec_End
  317. ;;;;;  Synchronisation écran 50Hz         ;;;;;
  318. Spec_60Hz
  319.     move.b    v_count_l.w,d0
  320.     beq.s    *-4
  321.     neg.b    d0
  322.     ror.l    d0,d0
  323.     moveq    #2,d0
  324.     ror.l    d0,d0
  325.     moveq    #62,d0
  326.     ror.l    d0,d0
  327. ;;;;;  Chargement des registres           ;;;;;
  328.     moveq    #$03,d0
  329.     moveq    #$c0,d1
  330.     moveq    #$00,d2
  331.     move.w    #198,d3
  332.     lea    b_ctrl(a0),a1
  333.     lea    b_y_count(a0),a0
  334.     lea    v_color0.w,a2
  335.     lea    v_color9.w,a3
  336. ;;;;;  Lancement du transfert de couleurs ;;;;;
  337. .line_bcl    movea.l    a3,a5
  338.     move.l    (a4)+,(a5)+
  339.     move.l    (a4)+,(a5)+
  340.     move.l    (a4)+,(a5)+
  341.     move.w    (a4)+,(a5)+
  342.     move.w    d0,(a0)
  343.     move.b    d1,(a1)
  344.     move.w    d2,(a2)
  345.     nop
  346.     dbf    d3,.line_bcl
  347. Spec_End    rts
  348. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  349. ;Chargement et décompactage du fichier demandé.
  350. ;Renvoie en A0 l'adresse de l'image finale...
  351. Load_Image
  352.     movem.l    d0-d7/a1-a6,-(sp)    ;
  353.     clr.w    -(sp)        ;on commence par ouvrir
  354.     pea    filename        ;le fichier
  355.     move.w    #$3d,-(sp)        ;
  356.     trap    #1        ;
  357.     addq.l    #8,sp        ;
  358.     move.w    d0,d7        ;
  359.     bmi    .LI_err2        ;
  360.     
  361.     move.w    #2,-(sp)        ;Aller en fin de fichier
  362.     move.w    d7,-(sp)        ;avec un Seek
  363.     clr.l    -(sp)        ;
  364.     move.w    #$42,-(sp)        ;
  365.     trap    #1        ;
  366.     move.l    d0,d6        ;=>taille du fichier !
  367.     clr.w    -(sp)        ;Puis revient en tête
  368.     move.w    d7,-(sp)        ;du fichier
  369.     clr.l    -(sp)        ;
  370.     move.w    #$42,-(sp)        ;
  371.     trap    #1        ;
  372.     lea    20(sp),sp        ;
  373.  
  374.     pea    Work_x(pc)        ;on lit les 16 premiers
  375.     moveq    #16,d0        ;octets pour reconnaitre
  376.     move.l    d0,-(sp)        ;le fichier
  377.     move.w    d7,-(sp)        ;
  378.     move.w    #$3f,-(sp)        ;
  379.     trap    #1        ;
  380.     clr.w    -(sp)        ;Puis on revient en
  381.     move.w    d7,-(sp)        ;tête de fichier...
  382.     clr.l    -(sp)        ;
  383.     move.w    #$42,-(sp)        ;
  384.     trap    #1        ;
  385.     lea    22(sp),sp        ;Rétablit la pile
  386.     cmpi.l    #"ICE!",Work_x    ;Compactage Ice ?
  387.     bne.s    .LI_0        ;non
  388.     move.l    Work_x+8,d6    ;Si, prendre la VRAIE taille
  389.     bra.s    .LI_1        ;
  390. .LI_0    cmpi.l    #"ATM5",Work_x    ;Compactage Atomik ?    
  391.     bne.s    .LI_1        ;
  392.     move.l    Work_x+4,d6    ;oui => VRAIE taille
  393.  
  394. .LI_1    move.l    d6,-(sp)        ;On demande la mémoire kivabien
  395.     move.w    #$48,-(sp)        ;
  396.     trap    #1        ;
  397.     addq.l    #6,sp        ;
  398.     move.l    d0,d5        ;
  399.     bgt.s    .LI_2        ;Adresse valable ?
  400. .LI_err1    lea    Memerr,a0        ;
  401.     bsr    Form_Alert        ;Non:pas de mémoire
  402.     moveq    #0,d0        ;
  403.     bra    .LI_end        ;
  404. .LI_err2    lea    Filerr,a0        ;
  405.     bsr    Form_Alert        ;
  406.     moveq    #0,d0        ;erreur fichier
  407.     bra    .LI_end        ;
  408.  
  409. .LI_2    move.l    d5,-(sp)        ;
  410.     move.l    d6,-(sp)        ;Lire le fichier
  411.     move.w    d7,-(sp)        ;
  412.     move.w    #$3f,-(sp)        ;
  413.     trap    #1        ;
  414.     move.w    d7,-(sp)        ;et ferme le
  415.     move.w    #$3e,-(sp)        ;
  416.     trap    #1        ;
  417.     lea    16(sp),sp        ;
  418.     movea.l    d5,a0        ;
  419.     bsr    ice_decrunch    ;tentative de dépackage
  420.     bsr    atm5_decrunch    ;ice ou atomik
  421.     moveq    #-1,d0        ;tout va bien
  422. .LI_end    movem.l    (sp)+,d0-d7/a1-a6    ;
  423.     rts            ;
  424. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  425. ;Sauvegarde de l'image BIM (Blitter-IMage)
  426. Save_Image    movem.l    d0-d7/a0-a6,-(sp)    ;
  427.     clr.w    -(sp)        ;
  428.     pea    filename        ;
  429.     move.w    #$3c,-(sp)        ;Create
  430.     trap    #1        ;
  431.     addq.l    #8,sp        ;
  432.     move.w    d0,d7        ;
  433.     bmi.s    .SI_err0        ;erreur d'ouverture
  434.     pea    pal_buf        ;adresse des palettes
  435.     move.l    #(48+7)*199*4,-(sp)    ;taille des palettes
  436.     move.w    d7,-(sp)        ;
  437.     move.w    #$40,-(sp)        ;hop
  438.     trap    #1        ;
  439.     move.l    ecran,-(sp)    ;adresses des écrans
  440.     move.l    #32000*2,-(sp)    ;leur taille
  441.     move.w    d7,-(sp)        ;
  442.     move.w    #$40,-(sp)        ;voilà qui est fait
  443.     trap    #1        ;
  444.     move.w    d7,-(sp)        ;et finalement ferme
  445.     move.w    #$3e,-(sp)        ;le fichier
  446.     trap    #1        ;
  447.     lea    28(sp),sp        ;
  448. .SI_end    movem.l    (sp)+,d0-d7/a0-a6    ;
  449.     rts
  450. .SI_err0    lea    Filerr,a0
  451.     bsr    Form_Alert
  452.     bra.s    .SI_end
  453. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  454. ;-------------------Convertion images 24 bits format RAW-----------------
  455. ; A0=adresse de l'image
  456. ; A1=adresse des deux écrans nécessaires
  457. ; A2=adresse des deux jeux de palettes.
  458. ; D0= 1:rusé / 0:normal / -1:réduction du clignotement
  459. ; D1= entrelacement (supérieur à 0 !!)
  460.     RSRESET
  461. compt_x    rs.w    1    ;compteur de pixels
  462. compt_y    rs.w    1    ;de lignes
  463. rez_x    rs.w    1    ;résolution de l'image 24 bits
  464. rez_y    rs.w    1    ;
  465. delta_y    rs.w    1    ;taille d'une de ses lignes
  466. flicker    rs.w    1    ;type de conversion ?
  467. swap    rs.w    1    ;<-pour l'antiflicker
  468.  
  469. col_1    rs.w    1    ;couleur 1 du point
  470. rgb_11    rs.w    1    ;pour recherche rusée, on
  471. idx_11    rs.w    1    ;regarde sa note, l'offset
  472. note11    rs.w    1    ;palette, la couleur choisie
  473. off_11    rs.w    1    ;et son index (0..15)
  474. rgb_12    rs.w    1    ;et ce pour les 2 images
  475. idx_12    rs.w    1    ;
  476. note12    rs.w    1    ;
  477. off_12    rs.w    1    ;
  478.  
  479. col_2    rs.w    1    ;et pareil pour la couleur 2
  480. rgb_21    rs.w    1    ;
  481. idx_21    rs.w    1    ;
  482. note21    rs.w    1    ;
  483. off_21    rs.w    1    ;
  484. rgb_22    rs.w    1    ;
  485. idx_22    rs.w    1    ;
  486. note22    rs.w    1    ;
  487. off_22    rs.w    1    ;
  488.  
  489. c24b_size    rs.b    0
  490.  
  491. Convert_24Bits
  492.     movem.l    d0-a6,-(sp)    ;
  493.     tst.w    d1        ;Selon l'entrelacement,
  494.     bne.s    *+4        ;nul=erreur
  495.     moveq    #1,d1        ;donc corrige
  496.     smi    d4        ;on avance ou on recule
  497.     ext.w    d4        ;-1=négatif 0=positif
  498.     add.w    d4,d4        ;-2         0
  499.     addq.w    #1,d4        ;-1        +1
  500.     lea    Suite_x(pc),a6    ;on va créer la suite des x
  501.     moveq    #0,d0        ;selon l'entrelacement
  502.     moveq    #0,d2        ;Valeur de départ=0
  503.     move.w    #319,d3        ;
  504. .C_i0    add.w    d1,d0        ;avance selon l'entrelacement
  505.     bpl.s    .C_i1        ;arg, négatif ?
  506.     addi.w    #320,d0        ;oui, donc modulo 320
  507.     bra.s    .C_i2        ;
  508. .C_i1    cmpi.w    #320,d0        ;on a dépassé la ligne ?
  509.     blt.s    .C_i2        ;non
  510.     subi.w    #320,d0        ;si, modulo 320
  511. .C_i2    move.w    d0,(a6)+        ;c'est le prochain x
  512.     cmp.w    d0,d2        ;On est revenu au départ ?
  513.     bne.s    .C_i4        ;
  514.     add.w    d4,d0        ;oui, alors avance/recule
  515.     bpl.s    .C_i3        ;de 1
  516.     addi.w    #320,d0
  517. .C_i3    move.w    d0,d2        ;c'est le nouveau départ
  518. .C_i4    dbf    d3,.C_i0        ;suivant.
  519.  
  520.     lea    C24B_dat1(pc),a6    ;
  521.     move.w    2(sp),flicker(a6)    ;
  522.     clr.w    swap(a6)        ;
  523.     tst.w    10(sp)        ;RAW ou TGA ???
  524.     beq    .C_raw        ;
  525.  
  526. .C_tga    move.b    13(a0),d0        ;Taille de l'image D0=x
  527.     lsl.w    #8,d0        ;
  528.     move.b    12(a0),d0        ;
  529.     move.b    15(a0),d1        ;et D1=y
  530.     lsl.w    #8,d1        ;
  531.     move.b    14(a0),d1        ;
  532.     move.w    d0,rez_x(a6)    ;conserve donc x et y
  533.     move.w    d1,rez_y(a6)    ;(largeur et hauteur de
  534.     mulu    #3,d0        ;l'image).x*y*3=taille
  535.     mulu    d0,d1        ;de l'image
  536.     move.w    d0,delta_y(a6)    ;3*x=taille d'une ligne
  537.     moveq    #18,d0        ;On saute l'en-tête
  538.     add.b    (a0),d0        ;du fichier TGA
  539.     adda.w    d0,a0        ;
  540.     lea    0(a0,d1.l),a4    ;on marque la fin de l'image
  541.     move.l    a0,a5        ;et on la traite
  542. .C_t0    move.b    (a5)+,d0        ;Maintenant, on va
  543.     lsr.b    #3,d0        ;réduire les données
  544.     add.b    d0,d0        ;RGB de chaque point
  545.     move.b    (a5),d1        ;(3 octets, un par composante)
  546.     lsr.b    #3,d1        ;Y'a 256 nuances par
  547.     add.b    d1,d1        ;composante=> on réduit à 32
  548.     move.b    d1,(a5)+        ;pour avoir 2*16.Attention,
  549.     move.b    (a5),d1        ;en TGA on a dans l'ordre
  550.     lsr.b    #3,d1        ;BRG=>en même temps,on remet
  551.     add.b    d1,d1        ;les composantes dans le bon
  552.     move.b    d1,-2(a5)        ;ordre.
  553.     move.b    d0,(a5)+        ;
  554.     cmpa.l    a4,a5        ;
  555.     blt.s    .C_t0        ;toute l'image ?
  556.     bra    .C_4
  557.     
  558. .C_raw    moveq    #0,d0        ;Initialise x
  559.     moveq    #0,d1        ;...et y
  560. .C_r0    moveq    #0,d2        ;
  561.     move.b    (a0)+,d2        ;Caractère suivant
  562.     cmpi.b    #32,d2        ;fin de la chaine x ?
  563.     beq.s    .C_r1        ;ouaip..
  564.     subi.b    #"0",d2        ;convert en chiffre décimal
  565.     mulu    #10,d0        ;
  566.     add.w    d2,d0        ;et hop
  567.     bra.s    .C_r0        ;
  568. .C_r1    moveq    #0,d2        ;maintenant, lecture de y
  569.     move.b    (a0)+,d2        ;
  570.     cmpi.b    #10,d2        ;condition d'arret: chr$(10)
  571.     beq.s    .C_r2        ;
  572.     subi.b    #"0",d2        ;
  573.     mulu    #10,d1        ;
  574.     add.w    d2,d1        ;
  575.     bra.s    .C_r1        ;
  576. .C_r2    move.w    d0,rez_x(a6)    ;conserve donc x et y
  577.     move.w    d1,rez_y(a6)    ;(largeur et hauteur de
  578.     mulu    #3,d0        ;l'image).x*y*3=taille
  579.     mulu    d0,d1        ;de l'image
  580.     move.w    d0,delta_y(a6)    ;3*x=taille d'une ligne
  581.     lea    0(a0,d1.l),a4    ;
  582.     movea.l    a0,a5        ;Exactement la même
  583. .C_r3    REPT    3        ;chose que pour le TGA
  584.     move.b    (a5),d0        ;mais le format RAW
  585.     lsr.b    #3,d0        ;est un RGB, donc pas
  586.     add.b    d0,d0        ;besoin de réordonner
  587.     move.b    d0,(a5)+        ;les composantes
  588.     ENDR            ;
  589.     cmpa.l    a4,a5        ;
  590.     blt.s    .C_r3        ;sur toute l'image
  591.  
  592. .C_4    move.l    a1,d1        ;maintenant, A1/D1=adresses
  593.     lea    32000(a1),a1    ;des 2 écrans et A2/D3 celles
  594.     move.l    a2,d2        ;des 2 blocs de palettes.
  595.     lea    199*(48+7)*2(a2),a2    ;
  596.     move.l    d1,a3        ;
  597.     moveq    #0,d6        ;
  598.     move.w    #3999,d7        ;
  599. .C_5    move.l    d6,(a3)+        ;Commence par un cls sur
  600.     move.l    d6,(a3)+        ;les deux écrans.
  601.     move.l    d6,(a3)+        ;
  602.     move.l    d6,(a3)+        ;
  603.     dbf    d7,.C_5        ;
  604.     lea    160(a1),a1        ;Seulement 199 lignes, la
  605.     addi.l    #160,d1        ;première est ignorée !..
  606.     move.l    d2,a3        ;Puis un cls de la palette
  607.     move.w    #199*2-1,d7    ;
  608. .C_6    move.l    d6,(a3)+        ;Les lignes de couleurs sont
  609.     move.l    d6,(a3)+        ;dans l'ordre: les 7 couleurs
  610.     move.l    d6,(a3)+        ;du 68000, et les 48 du blitter
  611.     move.w    d6,(a3)+        ;
  612.     move.w    #$f000,(a3)+    ;couleur 0 imposée !!
  613.     move.w    d6,(a3)+        ;(pour la bordure)
  614.     REPT    48/2-1        ;
  615.     move.l    d6,(a3)+        ;
  616.     ENDR            ;
  617.     dbf    d7,.C_6        ;ligne de palette suivante
  618.     
  619.  
  620.     move.w    rez_y(a6),d0    ;On commence la conversion
  621.     cmpi.w    #199,d0        ;proprement dite.
  622.     bls.s    *+6        ;Clipping de la hauteur
  623.     move.w    #199,d0        ;de l'écran
  624.     move.w    d0,compt_y(a6)    ;
  625.     lea    Convert_x(pc),a3    ;conversion x->palette
  626. .C_7    lea    Suite_x(pc),a4    ;Suite des coordonnées
  627.     move.w    #320,compt_x(a6)    ;320 points
  628.     move.w    -2(a2),-(sp)    ;Sauve emplacement parasite
  629.     move.w    #$1000,-2(a2)    ;couleur spéciale parasite
  630.     movea.l    d2,a5        ;Et ceci pour les deux blocs
  631.     move.w    -2(a5),-(sp)    ;
  632.     move.w    #$1000,-2(a5)    ;
  633.     
  634. ;Pendant l'algorithme:
  635. ;A0=ligne courante de l'image RGB
  636. ;A1/D1=adresses écrans 1 et 2 (ligne courante)
  637. ;A2/D2=adresses blocs de palettes 1 et 2 (ligne courante)
  638. ;A3=convertisseur x->palette      A4=suite de valeurs de x
  639. .C_8    move.w    (a4)+,d0        ;d0=x courant
  640.     cmp.w    rez_x(a6),d0    ;plus grand que la ligne ?
  641.     bge    .C_8end        ;oui,alors rien à faire !!
  642.     move.w    d0,d3        ;
  643.     add.w    d0,d0        ;D0=2*x
  644.     add.w    d0,d3        ;D3=3*x
  645.     lea    0(a0,d3.w),a5    ;3*x donne l'adresse du
  646.     moveq    #0,d3        ;
  647.     moveq    #0,d4        ;
  648.     moveq    #0,d5        ;
  649.     move.b    (a5)+,d3        ;point courant.
  650.     move.b    (a5)+,d4        ;on récupère sa couleur
  651.     move.b    (a5)+,d5        ;(d3,d4,d5)=(R,G,B)
  652.     moveq    #$f0,d6        ;Pour distinguer $f000 (noir)
  653.     moveq    #$f0,d7        ;de $0000 (libre), la couleur
  654.     movea.l    Convert_rgb(pc),a5    ;est $FRGB (=>si RGB=000,ca
  655.     or.b    0(a5,d3.w),d6    ;marche).En plus, cela sert
  656.     or.b    1(a5,d3.w),d7    ;pour utiliser l'anti-parasite
  657.     lsl.w    #4,d6        ;
  658.     lsl.w    #4,d7        ;
  659.     or.b    0(a5,d4.w),d6    ;D6 contient la valeur STE
  660.     or.b    1(a5,d4.w),d7    ;inférieure, et D7 la valeur
  661.     lsl.w    #4,d6        ;supérieure (on peut avoir
  662.     lsl.w    #4,d7        ;D6=D7 si la couleur du point
  663.     or.b    0(a5,d5.w),d6    ;est une vraie couleur STE)
  664.     or.b    1(a5,d5.w),d7    ;
  665.     add.w    d0,d0        ;x*4
  666.     move.w    d0,d5        ;conserve x*4 dans D5
  667.     lsl.w    #3,d0        ;x*4*8=x*32
  668.     tst.w    flicker(a6)    ;affichage optimisé ?
  669.     ble    .C_9        ;non, suivant
  670.  
  671.  
  672.  
  673. .C_ruse    move.w    d6,col_1(a6)    ;conserve la couleur 1
  674.     move.w    d7,col_2(a6)    ;et la couleur 2
  675.     bsr    .C_search        ;recherche dans palette 1
  676.     movem.l    d6-d7,rgb_11(a6)    ;stocke résultat
  677.     move.w    col_1(a6),d6    ;reprend couleur 1
  678.     exg.l    d2,a2        ;mais cherche dans palette 2
  679.     bsr    .C_search        ;recherche
  680.     movem.l    d6-d7,rgb_12(a6)    ;et stocke
  681.     move.w    col_2(a6),d6    ;pareil pour couleur 2
  682.     bsr    .C_search        ;
  683.     movem.l    d6-d7,rgb_21(a6)    ;
  684.     exg.l    d2,a2        ;
  685.     move.w    col_2(a6),d6    ;
  686.     bsr    .C_search        ;
  687.     movem.l    d6-d7,rgb_22(a6)    ;
  688.     move.w    note11(a6),d6    ;Maintenant, sommation
  689.     add.w    note21(a6),d6    ;des notes obtenus pour
  690.     move.w    note12(a6),d7    ;chaque essai.
  691.     add.w    note22(a6),d7    ;
  692.     move.l    a6,a5        ;
  693.     cmp.w    d6,d7        ;Quel est le meilleur choix?
  694.     bge.s    .Cr_0        ;le premier ?
  695.     move.w    off_11(a5),d7    ;Installe la 1ere combinaison
  696.     move.w    rgb_11(a5),0(a2,d7.w)    ;de couleurs choisie
  697.     move.w    idx_11(a5),d7    ;sur l'écran 1
  698.     exg.l    d2,a2        ;et sur l'écran 2
  699.     move.w    off_21(a5),d6    ;(=>palettes 1 et palettes 2)
  700.     move.w    rgb_21(a5),0(a2,d6.w)    ;
  701.     move.w    idx_21(a5),d6    ;
  702.     exg.l    d2,a2        ;
  703.     bra.s    .C_11        ;et on se raccorde.
  704. .Cr_0    exg.l    d2,a2
  705.     move.w    off_12(a5),d6    ;Installe la 2ème
  706.     move.w    rgb_12(a5),0(a2,d6.w)    ;(donc inversée !)
  707.     move.w    idx_12(a5),d6    ;
  708.     exg.l    d2,a2        ;
  709.     move.w    off_22(a5),d7    ;
  710.     move.w    rgb_22(a5),0(a2,d7.w)    ;
  711.     move.w    idx_22(a5),d7    ;
  712.     bra.s    .C_11
  713.  
  714.  
  715.  
  716. .C_9    beq.s    .C_10        ;routine simple ?
  717.     not.w    swap(a6)        ;non, alors inverse pour un
  718.     beq.s    *+4        ;point sur deux la valeur
  719.     exg    d6,d7        ;faible et forte de la couleur
  720. .C_10    bsr    .C_choix        ;Choisir la couleur dans les
  721.     exg    d6,d7        ;palettes 1 (écran 1)
  722.     exg    a2,d2        ;puis dans la palette 2
  723.     bsr    .C_choix        ;(écran 2)..
  724.     exg    a2,d2        ;remet A2/D2 comifo
  725.  
  726. .C_11    lea    Screen_x,a5    ;Maintenant, on plot la valeur
  727.     movem.w    0(a5,d5.w),d3-d4    ;du point selon le tableau
  728.     lea    0(a1,d3.w),a5    ;x->(offset,bitplan)
  729.     lsr.w    #1,d7        ;Selon la couleur de l'écran 1
  730.     bcc.s    *+4        ;on applique la valeur
  731.     or.w    d4,(a5)        ;du bitplan làouifo
  732.     lsr.w    #1,d7        ;
  733.     bcc.s    *+6        ;
  734.     or.w    d4,2(a5)        ;
  735.     lsr.w    #1,d7        ;
  736.     bcc.s    *+8        ;
  737.     or.w    d4,4(a5)        ;
  738.     tst.w    d7        ;
  739.     beq.s    *+6        ;
  740.     or.w    d4,6(a5)        ;
  741.     movea.l    d1,a5        ;Puis maintenant sur l'écran 2
  742.     adda.w    d3,a5        ;
  743.     lsr.w    #1,d6        ;
  744.     bcc.s    *+4        ;
  745.     or.w    d4,(a5)        ;
  746.     lsr.w    #1,d6        ;
  747.     bcc.s    *+6        ;
  748.     or.w    d4,2(a5)        ;
  749.     lsr.w    #1,d6        ;
  750.     bcc.s    *+8        ;
  751.     or.w    d4,4(a5)        ;
  752.     tst.w    d6        ;
  753.     beq.s    *+6        ;
  754.     or.w    d4,6(a5)        ;
  755. .C_8end    subq.w    #1,compt_x(a6)    ;point suivant de la ligne
  756.     bne    .C_8        ;
  757.     movea.l    d2,a5        ;Restitue l'emplacement qui
  758.     move.w    (sp)+,-2(a5)    ;a hébergé la couleur
  759.     move.w    (sp)+,-2(a2)    ;parasite
  760.     lea    160(a1),a1        ;Ligne écran suivante
  761.     addi.l    #160,d1        ;
  762.     lea    (48+7)*2(a2),a2    ;et ligne de palette suivante
  763.     addi.l    #(48+7)*2,d2    ;
  764.     adda.w    delta_y(a6),a0    ;Ne pas oublier: ligne suivante
  765.     not.w    swap(a6)        ;de l'image !!!!
  766.     subq.w    #1,compt_y(a6)    ;not.w pour l'anti-flicker
  767.     bne    .C_7        ;suivant
  768.     
  769.     movea.l    40(sp),a0        ;Maintenant, réarrange les
  770.     moveq    #1,d7        ;2 blocs de palettes..
  771. .C_12    move.l    a0,a3        ;Commence par recopier
  772.     lea    (48+7)*2*199(a0),a0    ;les 7 couleurs de
  773.     move.l    a0,a1        ;bordure de chaque ligne
  774.     move.w    #198,d6        ;dans un buffer
  775.     lea    Work_x+199*7*2,a2    ;on le fait de la fin vers
  776. .C_13    lea    -(48+7)*2(a0),a0    ;le début
  777.     movem.l    (a0),d0-d3        ;récupère les 7 couleurs
  778.     swap    d3        ;de la ligne
  779.     move.w    d3,-(a2)        ;
  780.     movem.l    d0-d2,-(a2)    ;et sauve-les
  781.     dbf    d6,.C_13        ;ligne suivante
  782.     move.l    a1,a0        ;Puis on regroupe les 48
  783.     move.w    #197,d6        ;autres couleurs de chaque
  784.     lea    -48*2(a1),a1    ;ligne
  785.     lea    -(48+7)*2(a0),a0    ;
  786. .C_14    rept    24        ;24*2=48
  787.     move.l    -(a0),-(a1)    ;
  788.     endr            ;
  789.     lea    -7*2(a0),a0    ;
  790.     dbf    d6,.C_14        ;ligne suivante
  791.     lea    (48+7)*2*199(a3),a0    ;Prépare passage ligne suivante
  792.     move.w    #198,d6        ;199*7 couleurs de bordure
  793. .C_15    move.l    (a2)+,(a3)+    ;à tasser au début du bloc
  794.     move.l    (a2)+,(a3)+    ;de palette
  795.     move.l    (a2)+,(a3)+    ;
  796.     move.w    (a2)+,(a3)+    ;
  797.     dbf    d6,.C_15        ;ligne suivante
  798.     dbf    d7,.C_12        ;bloc de palette suivant
  799.     move.l    #$0eee0eee,d5    ;recoder les couleurs
  800.     move.l    #$01110111,d6    ;la facon Atari-ST...
  801.     move.w    #(48+7)*199-1,d7    ;En effet le bit faible
  802.     move.l    40(sp),a0        ;en notation binaire
  803. .C_16    move.l    (a0),d0        ;devient le bit fort
  804.     move.l    d0,d1        ;pour les registres STE!!
  805.     and.l    d5,d0        ;Il est ignoré en STF.
  806.     and.l    d6,d1        ;
  807.     lsr.l    #1,d0        ;
  808.     lsl.l    #3,d1        ;
  809.     or.l    d1,d0        ;
  810.     move.l    d0,(a0)+        ;
  811.     dbf    d7,.C_16        ;
  812.     movem.l    (sp)+,d0-a6    ;
  813.     rts            ;
  814.  
  815. ;A0-A4 occupés
  816. ;D0-D2/D5/D7 occupés
  817. .C_choix    lea    0(a3,d0.w),a5    ;Va chercher la palette du
  818.     move.l    a5,-(sp)        ;point. Conserve son adresse
  819.     REPT    15        ;Pour chacune des 16 couleurs
  820.     move.w    (a5)+,d3        ;teste si celle que l'on veut
  821.     cmp.w    0(a2,d3.w),d6    ;est déjà utilisée.
  822.     beq.s    .Cc_ok0        ;si oui, alors fini!
  823.     ENDR
  824.     move.w    (a5)+,d3        ;Dernière couleur
  825.     cmp.w    0(a2,d3.w),d6    ;Alors, elle existe ?
  826.     bne.s    .Cc_new        ;Non=>une nouveauté !
  827. .Cc_ok0    sub.l    (sp)+,a5        ;couleur déjà existente
  828.     move.w    a5,d6        ;on se contente de 
  829.     lsr.w    #1,d6        ;récupérer le registre
  830.     subq.w    #1,d6        ;correspondant
  831.     rts            ;-1 car on a fait (a5)+
  832.  
  833. .Cc_new    lea    -14(a5),a5        ;commence par la couleur 9
  834.     REPT    7        ;pour la bordure.
  835.     move.w    (a5)+,d3        ;Maintenant,cherche si une
  836.     tst.w    0(a2,d3.w)        ;des couleurs de la palette
  837.     beq.s    .Cc_ok1        ;est libre
  838.     ENDR
  839.     lea    -32(a5),a5        ;puis test les couleurs 0..8
  840.     REPT    8        ;
  841.     move.w    (a5)+,d3        ;
  842.     tst.w    0(a2,d3.w)        ;
  843.     beq.s    .Cc_ok1        ;
  844.     ENDR
  845.     move.w    (a5)+,d3        ;Dernière tentative
  846.     tst.w    0(a2,d3.w)        ;Si y'a pas de couleurs
  847.     bne.s    .Cc_look        ;libres, gasp:faut continuer
  848. .Cc_ok1    move.w    d6,0(a2,d3.w)    ;Couleur nouvelle, on
  849.     sub.l    (sp)+,a5        ;la stocke
  850.     move.w    a5,d6        ;calcule le No du registre
  851.     lsr.w    #1,d6        ;/2 car mot=2 octets
  852.     subq.w    #1,d6        ;-1 car on teste (a5)+
  853.     rts            ;
  854.  
  855. ;Algo principal:chercher la couleur la plus proche.
  856. .Cc_look    movem.l    d0-d5/d7/a0,-(sp)    ;
  857.     move.w    d6,d5        ;Décompose la couleur voulue
  858.     moveq    #$000f,d7        ;en RGB
  859.     and.w    d6,d7        ;
  860.     andi.w    #$00f0,d6        ;
  861.     clr.b    d5        ;Conserve bit 24-31 aussi
  862.     move.w    #$7fff,d4        ;écart maximal pour commencer
  863.     moveq    #15,d3        ;16 couleurs à tester
  864.     lea    -18(a5),a5        ;revient au début de la palette
  865. .Cc_0    move.w    (a5)+,d0        ;
  866.     move.w    0(a2,d0.w),d0    ;
  867.     move.w    d0,d1        ;Décompose la couleur de
  868.     moveq    #$000f,d2        ;la palette
  869.     and.w    d0,d2        ;
  870.     andi.w    #$00f0,d1        ;
  871.     clr.b    d0        ;
  872.     sub.w    d7,d2        ;Puis regarde les écarts de
  873.     bpl.s    *+4        ;chaque composante (en valeur
  874.     neg.w    d2        ;absolue)
  875.     sub.w    d6,d1        ;
  876.     bpl.s    *+4        ;
  877.     neg.w    d1        ;
  878.     sub.w    d5,d0        ;
  879.     bpl.s    *+4        ;
  880.     neg.w    d0        ;
  881.     lsr.w    #8,d0        ;Aligne RGB dans les 4 bits
  882.     lsr.w    #4,d1        ;faibles.
  883.     cmp.w    d0,d1        ;Cherche le plus grand écart
  884.     ble.s    *+4        ;Delta_R<Delta_G ?
  885.     exg    d1,d0        ;oui, alors le + grand en D0
  886.     add.w    d0,d1        ;Effectue la somme de tous
  887.     add.w    d2,d1        ;les Delta_
  888.     cmp.w    d0,d2        ;Delta_B>MAX(Delta_R,Delta_G)?
  889.     ble.s    *+4        ;...
  890.     move.w    d2,d0        ;...
  891.     mulu    d1,d0        ;maximum*somme=erreur
  892.     cmp.w    d0,d4        ;Si l'erreur commise est plus
  893.     ble.s    *+8        ;petite
  894.     move.w    d3,d4        ;alors conserve le registre
  895.     swap    d4        ;correspondant et l'erreur
  896.     move.w    d0,d4        ;dans D4
  897.     dbf    d3,.Cc_0        ;couleur suivant
  898.     swap    d4        ;
  899.     eori.w    #15,d4        ;Récupère le registre associé
  900.     move.w    d4,d6        ;à la meileure couleur
  901.     movem.l    (sp)+,d0-d5/d7/a0    ;
  902.     addq.l    #4,sp        ;
  903.     rts            ;
  904.  
  905. ;Algo secondaire:même chose que précédemment mais
  906. ;sans choix définitif (il est fait par la routine appelante).
  907. .C_search    moveq    #-1,d7        ;par défaut, note minimale
  908.     lea    0(a3,d0.w),a5    ;(-1 dans le mot haut de d7)
  909.     move.l    a5,-(sp)        ;
  910.     REPT    15        ;
  911.     move.w    (a5)+,d3        ;
  912.     cmp.w    0(a2,d3.w),d6    ;
  913.     beq.s    .Cs_ok0        ;
  914.     ENDR
  915.     move.w    (a5)+,d3        ;
  916.     cmp.w    0(a2,d3.w),d6    ;
  917.     bne.s    .Cs_new        ;
  918. .Cs_ok0    move.w    d3,d7        ;couleur déjà existente
  919.     suba.l    (sp)+,a5        ;
  920.     swap    d6        ;conserve la valeur rgb
  921.     move.w    a5,d6        ;
  922.     lsr.w    #1,d6        ;
  923.     subq.w    #1,d6        ;
  924.     rts            ;
  925.  
  926. .Cs_new    moveq    #0,d7        ;note nulle:moins favorable.
  927.     lea    -14(a5),a5        ;
  928.     REPT    7        ;
  929.     move.w    (a5)+,d3        ;
  930.     tst.w    0(a2,d3.w)        ;
  931.     beq    .Cs_ok0        ;routine identique ici
  932.     ENDR
  933.     lea    -32(a5),a5        ;
  934.     REPT    9        ;
  935.     move.w    (a5)+,d3        ;
  936.     tst.w    0(a2,d3.w)        ;
  937.     beq    .Cs_ok0        ;
  938.     ENDR
  939.  
  940. .Cs_look    movem.l    d0-d5/a0,-(sp)    ;Note à déterminer pour
  941.     move.w    d6,d5        ;la couleur la plus proche
  942.     moveq    #$000f,d7        ;
  943.     and.w    d6,d7        ;
  944.     andi.w    #$00f0,d6        ;
  945.     clr.b    d5        ;
  946.     move.w    #$7fff,d4        ;
  947.     moveq    #15,d3        ;
  948.     lea    -18(a5),a5        ;
  949.     subq.l    #8,sp        ;petite place sur la pile
  950. .Cs_0    move.w    (a5)+,d0        ;
  951.     move.w    d0,2(sp)        ;offset palette et
  952.     move.w    0(a2,d0.w),d0    ;...
  953.     move.w    d0,(sp)        ;couleur actuelle.
  954.     move.w    d0,d1        ;
  955.     moveq    #$000f,d2        ;
  956.     and.w    d0,d2        ;
  957.     andi.w    #$00f0,d1        ;
  958.     clr.b    d0        ;
  959.     sub.w    d7,d2        ;
  960.     bpl.s    *+4        ;
  961.     neg.w    d2        ;
  962.     sub.w    d6,d1        ;
  963.     bpl.s    *+4        ;
  964.     neg.w    d1        ;
  965.     sub.w    d5,d0        ;
  966.     bpl.s    *+4        ;
  967.     neg.w    d0        ;
  968.     lsr.w    #8,d0        ;
  969.     lsr.w    #4,d1        ;
  970.     cmp.w    d0,d1        ;
  971.     ble.s    *+4        ;
  972.     exg    d1,d0        ;
  973.     add.w    d0,d1        ;
  974.     add.w    d2,d1        ;
  975.     cmp.w    d0,d2        ;
  976.     ble.s    *+4        ;
  977.     move.w    d2,d0        ;
  978.     mulu    d1,d0        ;
  979.     cmp.w    d0,d4        ;
  980.     ble.s    *+12        ;
  981.     move.w    d3,d4        ;
  982.     swap    d4        ;
  983.     move.w    d0,d4        ;
  984.     move.l    (sp),4(sp)        ;meilleur couleur actuelle
  985.     dbf    d3,.Cs_0        ;couleur suivante
  986.  
  987.     move.w    4(sp),d6        ;la meilleure est choisie
  988.     swap    d4        ;
  989.     move.l    d4,d7        ;la note donnée
  990.     move.w    6(sp),d7        ;et l'offset palette
  991.     swap    d6        ;
  992.     eori.w    #15,d4        ;Récupère le registre associé
  993.     move.w    d4,d6        ;à la meileure couleur
  994.     addq.l    #8,sp        ;
  995.     movem.l    (sp)+,d0-d5/a0    ;
  996.     addq.l    #4,sp        ;
  997.     rts            ;
  998.  
  999.  
  1000.     
  1001. Convert_STE            ;tableau de conversion
  1002.     dc.b    $0,$0        ;pour STE. Pour chaque
  1003.     dc.b    $0,$1        ;valeur 5 bits (0..31)
  1004.     dc.b    $1,$1        ;il y a deux valeurs
  1005.     dc.b    $1,$2        ;STE 4 bits (0..15)
  1006.     dc.b    $2,$2        ;cela donne une amplitude
  1007.     dc.b    $2,$3        ;0..30 (31 est impossible
  1008.     dc.b    $3,$3        ;à coder).
  1009.     dc.b    $3,$4        ;Donc on a 31 pseudo teintes
  1010.     dc.b    $4,$4        ;par composante R,G,B
  1011.     dc.b    $4,$5        ;Ce qui donne 29791 couleurs
  1012.     dc.b    $5,$5
  1013.     dc.b    $5,$6
  1014.     dc.b    $6,$6
  1015.     dc.b    $6,$7
  1016.     dc.b    $7,$7
  1017.     dc.b    $7,$8
  1018.     dc.b    $8,$8
  1019.     dc.b    $8,$9
  1020.     dc.b    $9,$9
  1021.     dc.b    $9,$a
  1022.     dc.b    $a,$a
  1023.     dc.b    $a,$b
  1024.     dc.b    $b,$b
  1025.     dc.b    $b,$c
  1026.     dc.b    $c,$c
  1027.     dc.b    $c,$d
  1028.     dc.b    $d,$d
  1029.     dc.b    $d,$e
  1030.     dc.b    $e,$e
  1031.     dc.b    $e,$f
  1032.     dc.b    $f,$f
  1033.     dc.b    $f,$f
  1034.  
  1035. Convert_STF            ;Tableau de convertion
  1036.     dc.b    $0,$0        ;STF. Pareil que pour STE
  1037.     dc.b    $0,$0        ;mais les composantes
  1038.     dc.b    $0,$2        ;ne vont que de 2 en 2
  1039.     dc.b    $0,$2        ;Donc 0,2,...,28
  1040.     dc.b    $2,$2        ;soit donc 15 valeurs
  1041.     dc.b    $2,$2        ;Au total 3375 couleurs
  1042.     dc.b    $2,$4
  1043.     dc.b    $2,$4
  1044.     dc.b    $4,$4
  1045.     dc.b    $4,$4
  1046.     dc.b    $4,$6
  1047.     dc.b    $4,$6
  1048.     dc.b    $6,$6
  1049.     dc.b    $6,$6
  1050.     dc.b    $6,$8
  1051.     dc.b    $6,$8
  1052.     dc.b    $8,$8
  1053.     dc.b    $8,$8
  1054.     dc.b    $8,$a
  1055.     dc.b    $8,$a
  1056.     dc.b    $a,$a
  1057.     dc.b    $a,$a
  1058.     dc.b    $a,$c
  1059.     dc.b    $a,$c
  1060.     dc.b    $c,$c
  1061.     dc.b    $c,$c
  1062.     dc.b    $c,$e
  1063.     dc.b    $c,$e
  1064.     dc.b    $e,$e
  1065.     dc.b    $e,$e
  1066.     dc.b    $e,$e
  1067.     dc.b    $e,$e
  1068. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1069. ;Précalcul classique les plots à effectuer à l'écran
  1070. ;
  1071. Precalc_Screen_x
  1072.     movem.l    d0-a6,-(sp)
  1073.     lea    Screen_x,a0
  1074.     moveq    #0,d0
  1075. .PSx_0    moveq    #15,d2
  1076.     move.w    d0,d1
  1077.     and.w    d1,d2
  1078.     sub.w    d2,d1
  1079.     lsr.w    #1,d1
  1080.     move.w    d1,(a0)+
  1081.     eori.w    #15,d2
  1082.     moveq    #0,d1
  1083.     bset    d2,d1
  1084.     move.w    d1,(a0)+
  1085.     addq.w    #1,d0
  1086.     cmpi.w    #320,d0
  1087.     bne.s    .PSx_0
  1088.     movem.l    (sp)+,d0-a6
  1089.     rts
  1090. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1091. ;Précalcul les correspondances entre coordonnées et palettes de
  1092. ;couleur. Version non anti-parasitée.
  1093. ;Normal_Convert_x
  1094. ;    movem.l    d0-a6,-(sp)
  1095. ;    moveq    #0,d0
  1096. ;    lea    Convert_x,a0
  1097. ;.NCx_bcl    move.l    a0,a2        ;conserve palette pour + tard
  1098. ;    moveq    #-32,d3        ;palette -1 à 0 (-1=bordure)
  1099. ;    moveq    #3+9*8,d1        ;aligne x sur le champ de palettes
  1100. ;    add.w    d0,d1        ;->d1 indique la position
  1101. ;    asr.w    #3,d1        ;depuis le début du chgt de pal
  1102. ;    moveq    #48,d2        ;4-1=3 palettes (3*16=48)
  1103. ;    and.w    d1,d2        ;entre quelles palettes est-on?
  1104. ;    add.w    d2,d3        ;on conserve le résultat en d3
  1105. ;    add.w    d2,d3        ;(qui est offset, donc *2)
  1106. ;    addi.w    #14,d3        ;décalage de 7 couleurs dû à
  1107. ;                ;la bordure
  1108. ;    sub.w    d2,d1        ;quel intermédiaire de palette?
  1109. ;    moveq    #15,d4        ;On est dans la palette
  1110. ;.NCx_b0    move.w    d3,(a0)+        ;mémorisée en d3 
  1111. ;    addq.w    #2,d3        ;couleur suivante
  1112. ;    dbf    d4,.NCx_b0        ;
  1113. ;    cmpi.w    #110,d3        ;extrème de la ligne ?
  1114. ;    bne.s    .NCx_b2        ;non:pour les points >316
  1115. ;    moveq    #14,d3        ;uniquement, la couleur de
  1116. ;    bra.s    .NCx_b2        ;fond redevient noire.
  1117. ;.NCx_b1    move.w    d3,(a2)+        ;La palette suivante entre
  1118. ;    addq.w    #2,d3        ;depuis le registre 0.
  1119. ;.NCx_b2    dbf    d1,.NCx_b1        ;sur la taille intermédiaire
  1120. ;    addq.w    #1,d0        ;point suivant
  1121. ;    cmpi.w    #320,d0        ;fini ?
  1122. ;    bne.s    .NCx_bcl
  1123. ;    movem.l    (sp)+,d0-a6
  1124. ;    rts
  1125. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1126. ;Précalcul les correspondances entre coordonnées et palettes de
  1127. ;couleur.Version anti-parasite !.
  1128. Antiparasite_Convert_x
  1129.     movem.l    d0-a6,-(sp)
  1130.     moveq    #0,d0
  1131.     lea    Convert_x,a0
  1132. .ACx_bcl    move.l    a0,a2        ;conserve palette pour + tard
  1133.     moveq    #-32,d3        ;palette -1 à 0 (-1=bordure)
  1134.     moveq    #3+9*8,d1        ;aligne x sur le champ de palettes
  1135.     add.w    d0,d1        ;->d1 indique la position
  1136.     moveq    #7,d5        ;conserve le modulo 7
  1137.     and.w    d1,d5        ;pour l'antiparasite
  1138.     lsr.w    #3,d1        ;depuis le début du chgt de pal
  1139.     moveq    #48,d2        ;4-1=3 palettes (3*16=48)
  1140.     and.w    d1,d2        ;entre quelles palettes est-on?
  1141.     add.w    d2,d3        ;on conserve le résultat en d3
  1142.     add.w    d2,d3        ;(qui est offset, donc *2)
  1143.     addi.w    #14,d3        ;décalage de 7 couleurs dû à
  1144.                 ;la bordure
  1145.     sub.w    d2,d1        ;quel intermédiaire de palette?
  1146.     moveq    #15,d4        ;On est dans la palette
  1147. .ACx_b0    move.w    d3,(a0)+        ;mémorisée en d3 
  1148.     addq.w    #2,d3        ;couleur suivante
  1149.     dbf    d4,.ACx_b0        ;
  1150.     cmpi.w    #110,d3        ;extrème de la ligne ?
  1151.     bne.s    .ACx_b2        ;non:pour les points >316
  1152.     moveq    #14,d3        ;uniquement, la couleur de
  1153.     bra.s    .ACx_b2        ;fond redevient noire.
  1154. .ACx_b1    move.w    d3,(a2)+        ;La palette suivante entre
  1155.     addq.w    #2,d3        ;depuis le registre 0.
  1156. .ACx_b2    dbf    d1,.ACx_b1        ;sur la taille intermédiaire
  1157.  
  1158.     subq.w    #7,d5        ;On est sur le pixel parasite?
  1159.     bne.s    .ACx_1        ;Non,saute skissui
  1160.     move.w    #-2,(a2)        ;si,enlève la couleur limite
  1161. .ACx_1    addq.w    #1,d0        ;point suivant
  1162.     cmpi.w    #320,d0        ;fini ?
  1163.     bne.s    .ACx_bcl
  1164.     movem.l    (sp)+,d0-a6
  1165.     rts
  1166.  
  1167.     include    "a:\inithard.s"
  1168.  
  1169. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1170. ;Déclaration de présence pour l'AES.
  1171. Appl_Init    move.l    a0,-(sp)
  1172.     lea    _Appl_Init(pc),a0
  1173.     bsr    AES
  1174.     movea.l    (sp)+,a0
  1175.     rts
  1176. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1177. ;Fin de l'application.
  1178. Appl_Exit    lea    _Appl_Exit(pc),a0    ;libère l'AES
  1179.     bsr    AES        ;
  1180.     clr.w    -(sp)        ;retour au bureau
  1181.     trap    #1        ;
  1182. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1183. ;Boite d'alerte. A0 doit contenir son texte.
  1184. ;D0 contient le bouton cliqué à la sortie
  1185. Form_Alert    move.l    a0,-(sp)        ;
  1186.     moveq    #0,d0        ;Récupère bouton par défaut
  1187.     move.b    (a0)+,d0        ;
  1188.     move.w    d0,int_in        ;passe le à l'AES
  1189.     move.l    a0,addr_in        ;et l'adresse du message
  1190.     lea    _Form_Alert(pc),a0    ;fonction Form_Alert
  1191.     bsr    AES        ;go!
  1192.     move.w    int_out,d0        ;paramètres de sortie
  1193.     movea.l    (sp)+,a0        ;
  1194.     rts            ;
  1195. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1196. ;Selecteur de fichiers. A0 doit contenir le chemin, A1 le nom
  1197. ;preselectionné (ou nul) et A2 l'adresse de la chaine qui
  1198. ;contiendra le nom du fichier complet.
  1199. ;En sortie Z=1 (BEQ) si erreur ou pas de choix
  1200. FileSelect    movem.l    a0-a2,-(sp)        ;
  1201.     move.l    a0,addr_in        ;
  1202.     move.l    a1,addr_in+4    ;
  1203.     lea    _FileSelect,a0    ;
  1204.     bsr    AES        ;
  1205.     tst.w    int_out        ;Erreur ?
  1206.     beq.s    .FS_end        ;
  1207.     tst.w    int_out+2        ;Bouton Cancel ?
  1208.     beq.s    .FS_end        ;
  1209.  
  1210.     movea.l    (sp),a0        ;récupère le chemin
  1211.     move.l    a0,a1        ;
  1212. .FS_0    tst.b    (a0)+        ;Cherche la fin
  1213.     bne.s    .FS_0        ;de la chaine
  1214. .FS_1    cmpi.b    #"\",-(a0)        ;Cherche l'anti-slash
  1215.     beq.s    .FS_2        ;de la fin du chemin
  1216.     cmpa.l    a0,a1        ;On a remonté la chaine?
  1217.     bne.s    .FS_1        ;pas encore...
  1218.     
  1219. .FS_2    movea.l    a0,a1        ;conserve cette adresse
  1220.     movea.l    (sp),a0        ;on repart du début
  1221. .FS_3    cmpa.l    a0,a1        ;déjà fini ?
  1222.     blt.s    .FS_4        ;oui
  1223.     move.b    (a0)+,(a2)+    ;
  1224.     bra.s    .FS_3        ;next one,plizzz
  1225.  
  1226. .FS_4    movea.l    4(sp),a1        ;maintenant, copie le nom
  1227. .FS_5    move.b    (a1)+,(a2)+    ;du fichier à la suite
  1228.     bne.s    .FS_5        ;pour composer le tout
  1229.     andi.w    #%11111011,ccr    ;Mettre Z=0:pas d'erreurs
  1230.  
  1231. .FS_end    movem.l    (sp)+,a0-a2    ;finito. C'est simple,
  1232.     rts            ;non ?
  1233. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1234. ;En A0: le descripteur de fonction voulu.
  1235. AES    movem.l    d0-a6,-(sp)
  1236.     lea    control,a1
  1237.     move.l    (a0)+,(a1)+
  1238.     move.l    (a0)+,(a1)+
  1239.     move.w    (a0)+,(a1)+
  1240.     move.w    #$c8,d0
  1241.     move.l    #AESPB,d1
  1242.     trap    #2
  1243.     movem.l    (sp)+,d0-a6
  1244.     rts
  1245. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1246. ;Routine de décompactage ICE 2.40 (c)Axe//Superior
  1247. ;
  1248. ice_decrunch:
  1249.     link    a3,#-120
  1250.     movem.l    d0-a6,-(sp)
  1251.     lea    120(a0),a4
  1252.     move.l    a4,a6
  1253.     bsr    .getinfo
  1254.     cmpi.l    #'ICE!',d0
  1255.     bne    .not_packed
  1256.     bsr.s    .getinfo
  1257.     lea.l    -8(a0,d0.l),a5
  1258.     bsr.s    .getinfo
  1259.     move.l    d0,(sp)
  1260.     adda.l    d0,a6
  1261.     move.l    a6,a1
  1262.  
  1263.     moveq    #119,d0
  1264. .save:    move.b    -(a1),-(a3)
  1265.     dbf    d0,.save
  1266.     move.l    a6,a3
  1267.     move.b    -(a5),d7
  1268.     bsr.s    .normal_bytes
  1269.     move.l    a3,a5
  1270.  
  1271.  
  1272.     bsr    .get_1_bit
  1273.     bcc.s    .no_picture
  1274.     move.w    #$0f9f,d7
  1275.     bsr    .get_1_bit
  1276.     bcc.s    .ice_00
  1277.     moveq    #15,d0
  1278.     bsr    .get_d0_bits
  1279.     move.w    d1,d7
  1280. .ice_00:    moveq    #3,d6
  1281. .ice_01:    move.w    -(a3),d4
  1282.     moveq    #3,d5
  1283. .ice_02:    add.w    d4,d4
  1284.     addx.w    d0,d0
  1285.     add.w    d4,d4
  1286.     addx.w    d1,d1
  1287.     add.w    d4,d4
  1288.     addx.w    d2,d2
  1289.     add.w    d4,d4
  1290.     addx.w    d3,d3
  1291.     dbra    d5,.ice_02
  1292.     dbra    d6,.ice_01
  1293.     movem.w    d0-d3,(a3)
  1294.     dbra    d7,.ice_00
  1295. .no_picture
  1296.     movem.l    (sp),d0-a3
  1297.  
  1298. .move    move.b    (a4)+,(a0)+
  1299.     subq.l    #1,d0
  1300.     bne.s    .move
  1301.     moveq    #119,d0
  1302. .rest    move.b    -(a3),-(a5)
  1303.     dbf    d0,.rest
  1304. .not_packed:
  1305.     movem.l    (sp)+,d0-a6
  1306.     unlk    a3
  1307.     rts
  1308.  
  1309. .getinfo: moveq    #3,d1
  1310. .getbytes: lsl.l    #8,d0
  1311.     move.b    (a0)+,d0
  1312.     dbf    d1,.getbytes
  1313.     rts
  1314.  
  1315. .normal_bytes:    
  1316.     bsr.s    .get_1_bit
  1317.     bcc.s    .test_if_end
  1318.     moveq.l    #0,d1
  1319.     bsr.s    .get_1_bit
  1320.     bcc.s    .copy_direkt
  1321.     lea.l    .direkt_tab+20(pc),a1
  1322.     moveq.l    #4,d3
  1323. .nextgb:    move.l    -(a1),d0
  1324.     bsr.s    .get_d0_bits
  1325.     swap.w    d0
  1326.     cmp.w    d0,d1
  1327.     dbne    d3,.nextgb
  1328. .no_more: add.l    20(a1),d1
  1329. .copy_direkt:    
  1330.     move.b    -(a5),-(a6)
  1331.     dbf    d1,.copy_direkt
  1332. .test_if_end:    
  1333.     cmpa.l    a4,a6
  1334.     bgt.s    .strings
  1335.     rts    
  1336.  
  1337. .get_1_bit:
  1338.     add.b    d7,d7
  1339.     bne.s    .bitfound
  1340.     move.b    -(a5),d7
  1341.     addx.b    d7,d7
  1342. .bitfound:
  1343.     rts    
  1344.  
  1345. .get_d0_bits:    
  1346.     moveq.l    #0,d1
  1347. .hole_bit_loop:    
  1348.     add.b    d7,d7
  1349.     bne.s    .on_d0
  1350.     move.b    -(a5),d7
  1351.     addx.b    d7,d7
  1352. .on_d0:    addx.w    d1,d1
  1353.     dbf    d0,.hole_bit_loop
  1354.     rts    
  1355.  
  1356.  
  1357. .strings: lea.l    .length_tab(pc),a1
  1358.     moveq.l    #3,d2
  1359. .get_length_bit:    
  1360.     bsr.s    .get_1_bit
  1361.     dbcc    d2,.get_length_bit
  1362. .no_length_bit:    
  1363.     moveq.l    #0,d4
  1364.     moveq.l    #0,d1
  1365.     move.b    1(a1,d2.w),d0
  1366.     ext.w    d0
  1367.     bmi.s    .no_über
  1368. .get_über:
  1369.     bsr.s    .get_d0_bits
  1370. .no_über:    move.b    6(a1,d2.w),d4
  1371.     add.w    d1,d4
  1372.     beq.s    .get_offset_2
  1373.  
  1374.  
  1375.     lea.l    .more_offset(pc),a1
  1376.     moveq.l    #1,d2
  1377. .getoffs: bsr.s    .get_1_bit
  1378.     dbcc    d2,.getoffs
  1379.     moveq.l    #0,d1
  1380.     move.b    1(a1,d2.w),d0
  1381.     ext.w    d0
  1382.     bsr.s    .get_d0_bits
  1383.     add.w    d2,d2
  1384.     add.w    6(a1,d2.w),d1
  1385.     bpl.s    .depack_bytes
  1386.     sub.w    d4,d1
  1387.     bra.s    .depack_bytes
  1388.  
  1389.  
  1390. .get_offset_2:    
  1391.     moveq.l    #0,d1
  1392.     moveq.l    #5,d0
  1393.     moveq.l    #-1,d2
  1394.     bsr.s    .get_1_bit
  1395.     bcc.s    .less_40
  1396.     moveq.l    #8,d0
  1397.     moveq.l    #$3f,d2
  1398. .less_40: bsr.s    .get_d0_bits
  1399.     add.w    d2,d1
  1400.  
  1401. .depack_bytes:
  1402.     lea.l    2(a6,d4.w),a1
  1403.     adda.w    d1,a1
  1404.     move.b    -(a1),-(a6)
  1405. .dep_b:    move.b    -(a1),-(a6)
  1406.     dbf    d4,.dep_b
  1407.     bra    .normal_bytes
  1408.  
  1409.  
  1410. .direkt_tab:
  1411.     dc.l $7fff000e,$00ff0007,$00070002,$00030001,$00030001
  1412.     dc.l     270-1,    15-1,     8-1,     5-1,     2-1
  1413.  
  1414. .length_tab:
  1415.     dc.b 9,1,0,-1,-1
  1416.     dc.b 8,4,2,1,0
  1417.  
  1418. .more_offset:
  1419.     dc.b      11,   4,   7,  0    ; Bits lesen
  1420.     dc.w    $11f,  -1, $1f    ; Standard Offset
  1421. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1422. ;Routine de décompactage Atomik 3.5 (c)Altair//VMAX
  1423. ;
  1424. MODE:    EQU    1
  1425. PIC_ALGO:    EQU    1
  1426. DEC_SPACE:    EQU    $1000
  1427. RESTORE_SPACE: EQU    1
  1428. atm5_decrunch:
  1429.     movem.l    d0-a6,-(a7)
  1430.     cmp.l    #"ATM5",(a0)+
  1431.     bne    not_packed
  1432.     link    a2,#-28
  1433.     move.l    (a0)+,d0
  1434.     ifne    MODE
  1435.     lea    4(a0,d0.l),a5
  1436.     move.l    d0,-(a7)
  1437.     elseif
  1438.     move.l    a1,a5
  1439.     add.l    d0,a5
  1440.     endc
  1441.     move.l    a5,a4
  1442.     ifne    MODE
  1443.     ifne    DEC_SPACE
  1444.     lea    DEC_SPACE(a4),a5
  1445.     endc
  1446.     endc
  1447.     lea    -$c(a4),a4
  1448.     move.l    (a0)+,d0
  1449.     move.l    a0,a6
  1450.     add.l    d0,a6
  1451.     ifne    PIC_ALGO
  1452.     moveq    #0,d0
  1453.     move.b    -(a6),d0
  1454.     move    d0,-2(a2)
  1455.     ifne    RESTORE_SPACE
  1456.     lsl    #2,d0
  1457.     sub    d0,a4
  1458.     endc
  1459.     elseif
  1460.     ifne    RESTORE_SPACE
  1461.     clr    -2(a2)
  1462.     endc
  1463.     subq    #1,a6
  1464.     endc
  1465.     ifne    RESTORE_SPACE
  1466.     lea    buff_marg(pc),a3
  1467.     move    -2(a2),d0
  1468.     lsl    #2,d0
  1469.     add    #DEC_SPACE+$C,d0
  1470.     bra.s    .save
  1471. .save_m:    move.b    (a4)+,(a3)+
  1472.     subq    #1,d0
  1473. .save:    bne.s    .save_m
  1474.     movem.l    a3-a4,-(a7)
  1475.     endc
  1476.     ifne    PIC_ALGO
  1477.     pea    (a5)
  1478.     endc
  1479.     move.b    -(a6),d7
  1480.     bra    take_type
  1481. decrunch:    move    d3,d5
  1482. take_lenght:    add.b    d7,d7
  1483. .cont_take:    dbcs    d5,take_lenght
  1484.     beq.s    .empty1
  1485.     bcc.s    .next_cod
  1486.     sub    d3,d5
  1487.     neg    d5
  1488.     bra.s    .do_copy1
  1489. .next_cod:    moveq    #3,d6
  1490.     bsr.s    get_bit2
  1491.     beq.s    .next_cod1
  1492.     bra.s    .do_copy
  1493. .next_cod1:    moveq    #7,d6
  1494.     bsr.s    get_bit2
  1495.     beq.s    .next_cod2
  1496.     add    #15,d5
  1497.     bra.s    .do_copy
  1498. .empty1:    move.b    -(a6),d7
  1499.     addx.b    d7,d7
  1500.     bra.s    .cont_take
  1501. .next_cod2:    moveq    #13,d6
  1502.     bsr.s    get_bit2
  1503.     add    #255+15,d5
  1504. .do_copy:    add    d3,d5
  1505. .do_copy1:    lea    decrun_table(pc),a4
  1506.     move    d5,d2
  1507.     bne.s    bigger
  1508.     add.b    d7,d7
  1509.     bne.s    .not_empty
  1510.     move.b    -(a6),d7
  1511.     addx.b    d7,d7
  1512. .not_empty:    bcs.s    .ho_kesako
  1513.     moveq    #1,d6
  1514.     bra.s    word
  1515. .ho_kesako:    moveq    #3,d6
  1516.     bsr.s    get_bit2
  1517.     tst.b    -28(a2)
  1518.     beq.s    .ho_kesako1
  1519.     move.b    10-28(a2,d5.w),-(a5)
  1520.     bra    tst_end
  1521. .ho_kesako1:    move.b    (a5),d0
  1522.     btst    #3,d5
  1523.     bne.s    .ho_kesako2
  1524.     bra.s    .ho_kesako3
  1525. .ho_kesako2:    add.b    #$f0,d5
  1526. .ho_kesako3:    sub.b    d5,d0
  1527.     move.b    d0,-(a5)
  1528.     bra    tst_end
  1529. get_bit2:    clr    d5
  1530. .get_bits:    add.b    d7,d7
  1531.     beq.s    .empty
  1532. .cont:    addx    d5,d5
  1533.     dbf    d6,.get_bits
  1534.     tst    d5
  1535.     rts
  1536. .empty:    move.b    -(a6),d7
  1537.     addx.b    d7,d7
  1538.     bra.s    .cont
  1539. bigger:    moveq    #2,d6
  1540. word:    bsr.s    get_bit2
  1541. contus:    move    d5,d4
  1542.     move.b    14(a4,d4.w),d6
  1543.     ext    d6
  1544.     tst.b    1-28(a2)
  1545.     bne.s    .spe_ofcod1
  1546.     addq    #4,d6
  1547.     bra.s    .nospe_ofcod1
  1548. .spe_ofcod1:    bsr.s    get_bit2
  1549.     move    d5,d1
  1550.     lsl    #4,d1
  1551.     moveq    #2,d6
  1552.     bsr.s    get_bit2
  1553.     cmp.b    #7,d5
  1554.     blt.s    .take_orof
  1555.     moveq    #0,d6
  1556.     bsr.s    get_bit2
  1557.     beq.s    .its_little
  1558.     moveq    #2,d6
  1559.     bsr.s    get_bit2
  1560.     add    d5,d5
  1561.     or    d1,d5
  1562.     bra.s    .spe_ofcod2
  1563. .its_little:    or.b    2-28(a2),d1
  1564.     bra.s    .spe_ofcod3
  1565. .take_orof:    or.b    3-28(a2,d5.w),d1
  1566. .spe_ofcod3:    move    d1,d5
  1567.     bra.s    .spe_ofcod2
  1568. .nospe_ofcod1:    bsr.s    get_bit2
  1569. .spe_ofcod2:    add    d4,d4
  1570.     beq.s    .first
  1571.     add    -2(a4,d4.w),d5
  1572. .first:    lea    1(a5,d5.w),a4
  1573.     move.b    -(a4),-(a5)
  1574. .copy_same:    move.b    -(a4),-(a5)
  1575.     dbf    d2,.copy_same
  1576.     bra.s    tst_end
  1577. make_jnk:    add.b    d7,d7
  1578.     bne.s    .not_empty
  1579.     move.b    -(a6),d7
  1580.     addx.b    d7,d7
  1581. .not_empty:    bcs.s    string
  1582.     move.b    -(a6),-(a5)
  1583. tst_end:    cmp.l    a5,a3
  1584.     bne.s    make_jnk
  1585.     cmp.l    a6,a0
  1586.     beq.s    work_done
  1587. take_type:    moveq    #0,d6
  1588.     bsr    get_bit2
  1589.     beq.s    .nospe_ofcod
  1590.     move.b    -(a6),d0
  1591.     lea    2-28(a2),a1
  1592.     move.b    d0,(a1)+
  1593.     moveq    #1,d1
  1594.     moveq    #6,d2
  1595. .next:    cmp.b    d0,d1
  1596.     bne.s    .no_off_4b
  1597.     addq    #2,d1
  1598. .no_off_4b:    move.b    d1,(a1)+
  1599.     addq    #2,d1
  1600.     dbf    d2,.next
  1601.     st    1-28(a2)
  1602.     bra.s    .spe_ofcod
  1603. .nospe_ofcod:    sf    1-28(a2)
  1604. .spe_ofcod:    moveq    #0,d6
  1605.     bsr    get_bit2
  1606.     beq.s    .relatif
  1607.     lea    10-28(a2),a1
  1608.     moveq    #15,d0
  1609. .next_f:    move.b    -(a6),(a1)+
  1610.     dbf    d0,.next_f
  1611.     st    -28(a2)
  1612.     bra.s    .freq
  1613. .relatif:    sf    -28(a2)
  1614. .freq:    clr    d3
  1615.     move.b    -(a6),d3
  1616.     move.b    -(a6),d0
  1617.     lsl    #8,d0
  1618.     move.b    -(a6),d0
  1619.     move.l    a5,a3
  1620.     sub    d0,a3
  1621.     bra.s    make_jnk
  1622. string:    bra    decrunch
  1623. work_done:
  1624.     ifne    PIC_ALGO
  1625.     move.l    (a7)+,a0
  1626.     pea    (a2)
  1627.     bsr.s    decod_picture
  1628.     move.l    (a7)+,a2
  1629.     endc
  1630.     ifne    RESTORE_SPACE
  1631.     movem.l    (a7)+,a3-a4
  1632.     endc
  1633.     ifne    MODE
  1634.     move.l    (a7)+,d0
  1635.     bsr    copy_decrun
  1636.     endc
  1637.     ifne    RESTORE_SPACE
  1638.     move    -2(a2),d0
  1639.     lsl    #2,d0
  1640.     add    #DEC_SPACE+$C,d0
  1641.     bra.s    .restore
  1642. .restore_m:    move.b    -(a3),-(a4)
  1643.     subq    #1,d0
  1644. .restore:    bne.s    .restore_m
  1645.     endc
  1646.     unlk    a2
  1647. not_packed:    movem.l    (a7)+,d0-a6
  1648.      rts
  1649. decrun_table:    dc.w    32,32+64,32+64+256,32+64+256+512,32+64+256+512+1024
  1650.     dc.w    32+64+256+512+1024+2048,32+64+256+512+1024+2048+4096
  1651.     dc.b    0,1,3,4,5,6,7,8
  1652.     ifne    PIC_ALGO
  1653. decod_picture:    move    -2(a2),d7
  1654. .next_picture:    dbf    d7,.decod_algo
  1655.     rts
  1656. .decod_algo:    move.l    -(a0),d0
  1657.     lea    0(a5,d0.l),a1
  1658. .no_odd:    lea    $7d00(a1),a2
  1659. .next_planes:    moveq    #3,d6
  1660. .next_word:    move    (a1)+,d0
  1661.     moveq    #3,d5
  1662. .next_bits:    add    d0,d0
  1663.     addx    d1,d1
  1664.     add    d0,d0
  1665.     addx    d2,d2
  1666.     add    d0,d0
  1667.     addx    d3,d3
  1668.     add    d0,d0
  1669.     addx    d4,d4
  1670.     dbf    d5,.next_bits
  1671.     dbf    d6,.next_word
  1672.     movem    d1-d4,-8(a1)
  1673.     cmp.l    a1,a2
  1674.     bne.s    .next_planes
  1675.     bra.s    .next_picture
  1676.     endc
  1677.     ifne    MODE
  1678. copy_decrun:    lsr.l    #4,d0
  1679.     lea    -12(a6),a6
  1680. .copy_decrun:    rept    4
  1681.     move.l    (a5)+,(a6)+
  1682.     endr
  1683.     dbf    d0,.copy_decrun
  1684.     rts
  1685.     endc
  1686.  
  1687.  
  1688.     SECTION    DATA
  1689. InfoDis1    dc.b    1,"[0][       Convertisseur|      d'images TGA&RAW| |(C)oderight Nullos//DNT 1992  | ][ Let's go! ]",0,0
  1690. InfoDis2    dc.b    1,"[1][Ce programme reconnait|automatiquement les|fichiers compactés avec|le ICE-Packer 2.4 ou|l'Atomik-packer 3.5][ Ok ]",0,0
  1691. KelForm    dc.b    0,"[2][Quel est le format|de l'image à traiter ?  ][ RAW | TGA | BIM ]",0,0
  1692. ConvTyp    dc.b    1,"[2][Quelle type de conversion|doit-on appliquer ?...  ][ Stable | Simple | Rusée ]",0,0
  1693. ConvNum    dc.b    2,"[2][Paramètre|d'entrelacement...        ][ ⇦ |"
  1694. _CN_str    dc.b    "+13| ⇨ ]",0,0
  1695. ConvHtz    dc.b    1,"[2][Frequence d'affichage|désirée ?....              ][ 60Hz | 50Hz ]",0,0
  1696. NextOne    dc.b    1,"[2][Une autre ?..][ Oui | Non ]",0,0
  1697. SavePic    dc.b    2,"[2][Voulez vous sauvegarder|l'image obtenue au format|BIM (Blitter-IMage) ?][ Oui | Non ]",0,0
  1698. Memerr    dc.b    1,"[3][Pas assez de mémoire pour|charger ce fichier-image][ Gasp ]",0,0
  1699. Filerr    dc.b    1,"[3][Impossible d'ouvrir ce|fichier....][ Gasp ]",0,0
  1700. Bliterr    dc.b    1,"[1][Ce programme ne marche|que sur les STE et|les STF avec blitter !!!!][ Dommaaaage ]",0,0
  1701.     EVEN
  1702.  
  1703. ;Descripteurs de fonction GEM : No de fonction,
  1704. ;                               Nombre de paramètres int_in
  1705. ;                                ""         ""       int_out
  1706. ;                                ""         ""       addr_in
  1707. ;                                ""         ""       addr_out
  1708. _Appl_Init  dc.w    10,0,1,0,0
  1709. _Appl_Exit  dc.w    19,0,1,0,0
  1710. _Form_Alert dc.w    52,1,1,1,0
  1711. _FileSelect dc.w    90,0,2,2,0
  1712.  
  1713.  
  1714. ecran    dc.l    0,0        ;Swapping écran
  1715. palette    dc.l    pal_buf,pal_buf+199*(48+7)*2 ;et de palettes
  1716. Convert_rgb dc.l    Convert_STF    ;Convertion STE ou STF
  1717. AESPB    dc.l    control,global,int_in,int_out,addr_in,addr_out
  1718.  
  1719.     SECTION    BSS
  1720. ; Tableau pour la routine de conversion d'image.
  1721. entrelace    ds.w    1        ;choix d'entrelacement
  1722. flickflag    ds.w    1        ;flicker/error free.
  1723. image    ds.l    1        ;adresse de l'image RBG
  1724. imtype    ds.w    1        ;TGA ou RAW ??
  1725. specsync    ds.w    1        ;50 ou 60Hz
  1726.  
  1727. C24B_dat1    ds.b    c24b_size        ;Tableau interne routine
  1728. Suite_x    ds.w    320        ;Suite des x de conversion
  1729. Work_x    ds.w    7*199        ;Réarrangement des palettes
  1730. Convert_x    ds.w    320*16        ;Convertion x->palette
  1731. Screen_x    ds.l    320        ;Convertion x->plot
  1732. pal_buf    ds.w    (48+7)*199*2    ;Bloc des palettes.
  1733. scr_buf    ds.b    32000*2+256    ;buffer d'image.
  1734. buff_marg    equ    pal_buf        ;Buffer pour Atomik
  1735.                 ;on le prend dans les palettes
  1736.  
  1737. filename    ds.b    128        ;Nom complet=
  1738. path    ds.b    128        ;Chemin pour FileSelect
  1739. name    ds.b    14        ;+nom du fichier
  1740.  
  1741. ; Tableaux du GEM.
  1742. control    ds.w    5
  1743. global    ds.w    15
  1744. int_in    ds.w    16
  1745. int_out    ds.w    7
  1746. addr_in    ds.l    2
  1747. addr_out    ds.l    1
  1748. ap_id    ds.w    1
  1749.  
  1750. ; Pile du programme.
  1751. .stack    ds.b    2048
  1752. stackup    equ    *