home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / programming / source / sftwist.lha / SFasm.asm < prev    next >
Encoding:
Assembly Source File  |  1993-07-21  |  9.8 KB  |  319 lines
  1.   CODE,PUBLIC
  2. *****    VOID __regargs UnPackSLZ(UBYTE *from, UBYTE *to)
  3. *****        calling from assembly:      a0   ,       a1
  4. CS_MASK   EQU  31
  5. CS_LSL    EQU  3
  6.  
  7.          XDEF @UnPackSLZ
  8. @UnPackSLZ:
  9.  
  10.             movem.l d2-d3/a2,-(SP)  ; Save Registers
  11.  
  12.             bra.b   slz_start       ; Skip to entry point
  13.  
  14. slz_literal move.b  (a0)+,(a1)+     ; Copy 8 byte literal string FAST!
  15.             move.b  (a0)+,(a1)+
  16.             move.b  (a0)+,(a1)+
  17.             move.b  (a0)+,(a1)+
  18.             move.b  (a0)+,(a1)+
  19.             move.b  (a0)+,(a1)+
  20.             move.b  (a0)+,(a1)+
  21.             move.b  (a0)+,(a1)+
  22.  
  23. slz_start   move.b  (a0)+,d0        ; Load compression TAG
  24.             beq.b   slz_literal     ; 8-byte literal string?
  25.  
  26.             moveq   #7,d1           ; Loop thru 8 bits
  27. slz_nxtloop add.b   d0,d0           ; Set flags for this compression TAG
  28.             bcs.b   slz_comp        ; If bit is set then compress
  29.             move.b  (a0)+,(a1)+     ; Otherwise copy a literal byte
  30.             dbf     d1,slz_nxtloop  ; Check and loop through 8 iterations
  31.             bra.b   slz_start       ; Get next TAG
  32.  
  33. slz_comp    moveq   #0,d2           ; Clear offset register
  34.             move.b  (a0)+,d2        ; Load compression specifier (cs) into d2
  35.             beq.b   slz_exit        ; If cs is 0, exit (decompression finished)
  36.             moveq   #CS_MASK,d3     ; Copy cs into number reg and mask off bits
  37.             and.w   d2,d3           ;   num = ( cs & CS_MASK ) [+ 2] ; {at least 3}
  38.             lsl.w   #CS_LSL,d2      ; Multiply cs_or by (2^CS_LSL)
  39.             move.b  (a0)+,d2        ;   and replace lsb with rest of cs
  40.             movea.l a1,a2           ; Now compute the offset from the current
  41.             suba.w  d2,a2           ;   output pointer
  42.  
  43.             add.w   d3,d3           ; Compute the unroll offset and begin
  44.             neg.w   d3              ;   unrolled compressed data expansion
  45.             jmp     slz_unroll(pc,d3.w)
  46.  
  47. slz_exit    movem.l (SP)+,d2-d3/a2  ; Restore Registers
  48.             rts                     ; EXIT routine
  49.  
  50.             move.b  (a2)+,(a1)+     ; 33
  51.             move.b  (a2)+,(a1)+     ; 32
  52.             move.b  (a2)+,(a1)+     ; 31
  53.             move.b  (a2)+,(a1)+     ; 30
  54.             move.b  (a2)+,(a1)+     ; 29
  55.             move.b  (a2)+,(a1)+     ; 28
  56.             move.b  (a2)+,(a1)+     ; 27
  57.             move.b  (a2)+,(a1)+     ; 26
  58.             move.b  (a2)+,(a1)+     ; 25
  59.             move.b  (a2)+,(a1)+     ; 24
  60.             move.b  (a2)+,(a1)+     ; 23
  61.             move.b  (a2)+,(a1)+     ; 22
  62.             move.b  (a2)+,(a1)+     ; 21
  63.             move.b  (a2)+,(a1)+     ; 20
  64.             move.b  (a2)+,(a1)+     ; 19
  65.             move.b  (a2)+,(a1)+     ; 18
  66.             move.b  (a2)+,(a1)+     ; 17
  67.             move.b  (a2)+,(a1)+     ; 16
  68.             move.b  (a2)+,(a1)+     ; 15
  69.             move.b  (a2)+,(a1)+     ; 14
  70.             move.b  (a2)+,(a1)+     ; 13
  71.             move.b  (a2)+,(a1)+     ; 12
  72.             move.b  (a2)+,(a1)+     ; 11
  73.             move.b  (a2)+,(a1)+     ; 10
  74.             move.b  (a2)+,(a1)+     ;  9
  75.             move.b  (a2)+,(a1)+     ;  8
  76.             move.b  (a2)+,(a1)+     ;  7
  77.             move.b  (a2)+,(a1)+     ;  6
  78.             move.b  (a2)+,(a1)+     ;  5
  79.             move.b  (a2)+,(a1)+     ;  4
  80.             move.b  (a2)+,(a1)+     ;  3
  81. slz_unroll  move.b  (a2)+,(a1)+     ;  2
  82.             move.b  (a2)+,(a1)+     ;  1
  83.  
  84.             dbf     d1,slz_nxtloop  ; Check and loop through 8 iterations
  85.             bra.s   slz_start       ; Process Next TAG
  86.  
  87. ***** VOID __regargs BresenFold(UBYTE *from_a0, UBYTE *to_a1)
  88. @BresenFold::
  89.      move.l    (a0)+,(a1)+
  90.      move.l    (a0)+,(a1)+
  91.      move.l    (a0)+,(a1)+
  92.      move.l    (a0)+,(a1)+
  93.      move.l    (a0)+,(a1)+
  94.      move.l    (a0)+,(a1)+
  95.      move.l    (a0)+,(a1)+
  96.      move.l    (a0)+,(a1)+
  97.      move.l    (a0)+,(a1)+
  98.      move.l    (a0)+,(a1)+
  99.      rts
  100.  
  101. ***** VOID __regargs ReverseIt(UBYTE *from_a0, UBYTE *to_a1);
  102. @ReverseIt::
  103.      lea       40(a0),a0
  104.      moveq.l   #0,d0
  105.      moveq.l   #7,d1
  106. rvi_loop
  107.      move.b    -(a0),d0
  108.      move.b    REVDATA(PC,d0.w),(a1)+
  109.      move.b    -(a0),d0
  110.      move.b    REVDATA(PC,d0.w),(a1)+
  111.      move.b    -(a0),d0
  112.      move.b    REVDATA(PC,d0.w),(a1)+
  113.      move.b    -(a0),d0
  114.      move.b    REVDATA(PC,d0.w),(a1)+
  115.      move.b    -(a0),d0
  116.      move.b    REVDATA(PC,d0.w),(a1)+
  117.      dbf.s     d1,rvi_loop
  118.  
  119.      rts
  120.  
  121. REVDATA:
  122.      dc.b 0,128,64,192,32,160,96,224
  123.      dc.b 16,144,80,208,48,176,112,240
  124.      dc.b 8,136,72,200,40,168,104,232
  125.      dc.b 24,152,88,216,56,184,120,248
  126.      dc.b 4,132,68,196,36,164,100,228
  127.      dc.b 20,148,84,212,52,180,116,244
  128.      dc.b 12,140,76,204,44,172,108,236
  129.      dc.b 28,156,92,220,60,188,124,252
  130.      dc.b 2,130,66,194,34,162,98,226
  131.      dc.b 18,146,82,210,50,178,114,242
  132.      dc.b 10,138,74,202,42,170,106,234
  133.      dc.b 26,154,90,218,58,186,122,250
  134.      dc.b 6,134,70,198,38,166,102,230
  135.      dc.b 22,150,86,214,54,182,118,246
  136.      dc.b 14,142,78,206,46,174,110,238
  137.      dc.b 30,158,94,222,62,190,126,254
  138.      dc.b 1,129,65,193,33,161,97,225
  139.      dc.b 17,145,81,209,49,177,113,241
  140.      dc.b 9,137,73,201,41,169,105,233
  141.      dc.b 25,153,89,217,57,185,121,249
  142.      dc.b 5,133,69,197,37,165,101,229
  143.      dc.b 21,149,85,213,53,181,117,245
  144.      dc.b 13,141,77,205,45,173,109,237
  145.      dc.b 29,157,93,221,61,189,125,253
  146.      dc.b 3,131,67,195,35,163,99,227
  147.      dc.b 19,147,83,211,51,179,115,243
  148.      dc.b 11,139,75,203,43,171,107,235
  149.      dc.b 27,155,91,219,59,187,123,251
  150.      dc.b 7,135,71,199,39,167,103,231
  151.      dc.b 23,151,87,215,55,183,119,247
  152.      dc.b 15,143,79,207,47,175,111,239
  153.      dc.b 31,159,95,223,63,191,127,255
  154.  
  155. ***** VOID __regargs GoLine(WORD line_d0);
  156.      xref _DOLINE
  157.      xref _MASSIVE_STORAGE
  158. @GoLine::
  159.      movem.l   d2-d7,-(SP)
  160.                               ; {
  161.                               ;   WORD loop_d1,width_d1;  //free = d2
  162.                               ;   WORD delta_stab_d3;
  163.                               ;   WORD delta_d4,position_d5;
  164.                               ;   WORD takeoff_d6;
  165.                               ;   WORD *to_a0,write_word_d7;
  166.  
  167.                               ;   UBYTE DOLINE_a1[320];
  168.  
  169.                               ;   CreateMasque(&BM0_a0[line_d0],DOLINE_a1,40);
  170.      BASEREG a4
  171.      lea       _DOLINE(a4),a1
  172.      BASEREG OFF
  173.      lea       _BM0,a0
  174.      adda.w    d0,a0
  175.  
  176.      moveq.l   #39,d4
  177.      moveq.l   #1,d1
  178.      moveq.l   #0,d2
  179.  
  180. cm_begin
  181.      move.b    (a0)+,d3
  182.      bpl.s     cm_c0
  183.      move.b    d1,(a1)+
  184.      bra.s     cm_s0
  185. cm_c0
  186.      move.b    d2,(a1)+
  187. cm_s0
  188.      add.b     d3,d3
  189.      bpl.s     cm_c1
  190.      move.b    d1,(a1)+
  191.      bra.s     cm_s1
  192. cm_c1
  193.      move.b    d2,(a1)+
  194. cm_s1
  195.      add.b     d3,d3
  196.      bpl.s     cm_c2
  197.      move.b    d1,(a1)+
  198.      bra.s     cm_s2
  199. cm_c2
  200.      move.b    d2,(a1)+
  201. cm_s2
  202.      add.b     d3,d3
  203.      bpl.s     cm_c3
  204.      move.b    d1,(a1)+
  205.      bra.s     cm_s3
  206. cm_c3
  207.      move.b    d2,(a1)+
  208. cm_s3
  209.      add.b     d3,d3
  210.      bpl.s     cm_c4
  211.      move.b    d1,(a1)+
  212.      bra.s     cm_s4
  213. cm_c4
  214.      move.b    d2,(a1)+
  215. cm_s4
  216.      add.b     d3,d3
  217.      bpl.s     cm_c5
  218.      move.b    d1,(a1)+
  219.      bra.s     cm_s5
  220. cm_c5
  221.      move.b    d2,(a1)+
  222. cm_s5
  223.      add.b     d3,d3
  224.      bpl.s     cm_c6
  225.      move.b    d1,(a1)+
  226.      bra.s     cm_s6
  227. cm_c6
  228.      move.b    d2,(a1)+
  229. cm_s6
  230.      add.b     d3,d3
  231.      bpl.s     cm_c7
  232.      move.b    d1,(a1)+
  233.      bra.s     cm_s7
  234. cm_c7
  235.      move.b    d2,(a1)+
  236. cm_s7
  237.  
  238.      dbf.s     d4,cm_begin
  239.  
  240.      BASEREG a4
  241.      lea       _DOLINE(a4),a1
  242.      BASEREG OFF
  243. ;     jmp       gl_out
  244.  
  245.      moveq.l   #0,d1          ;   for(loop_d1=0;loop_d1!=80;loop_d1++)
  246. gl_ford1                      ;     {
  247.      moveq.l   #0,d7          ;       write_word_d7=0;
  248.      move.w    #160,d4        ;       delta_d4=160; position_d5=-1;
  249.      moveq.l   #-1,d5
  250.  
  251.      lsl.w     #2,d1
  252.  
  253.      BASEREG a4               ;       to_a0=(WORD *)&MASSIVE_STORAGE_a0[loop_d1][line_d0];
  254.      lea       _MASSIVE_STORAGE(a4),a0
  255.      movea.l   0(a0,d1.w),a0
  256.      adda.w    d0,a0
  257.      BASEREG OFF
  258.  
  259.      addq.w    #4,d1          ;       width_d1=(loop_d1+1)*4;
  260.      move.w    #320,d6        ;       takeoff_d6=(320-width_d1)/2;
  261.      sub.w     d1,d6
  262.      lsr.w     #1,d6
  263.      move.w    d6,d2          ;       to_a0+=(takeoff_d6>>4);
  264.      lsr.w     #4,d2
  265.      add.w     d2,d2
  266.      adda.w    d2,a0
  267.      and.w     #15,d6         ;       takeoff_d6&=15;
  268.  
  269.      moveq.l   #0,d3          ;       for(delta_stab_d3=0; delta_stab_d3<width_d1; delta_stab_d3++)
  270.                               ;         {
  271.                               ;           while(delta_d4>=0)
  272. gl_whld4                      ;             {
  273.      addq.w    #1,d5          ;               position_d5++;
  274.      sub.w     d1,d4          ;               delta_d4-=width_d1;
  275.      bpl.s     gl_whld4       ;             }
  276.  
  277.      add.w     d7,d7          ;           write_word_d7=(write_word_d7*2)|DOLINE_a1[position_d5];
  278.      or.b      0(a1,d5.w),d7
  279.      addq.w    #1,d6          ;           if((++takeoff_d6)==16)
  280.      cmp.w     #16,d6         ;             {
  281.      bne.s     gl_skip1
  282.      moveq.l   #0,d6          ;               takeoff_d6=0;
  283.      move.w    d7,(a0)+       ;               *(to_a0++)=write_word_d7;
  284. gl_skip1                      ;             }
  285.      add.w     #320,d4        ;           delta_d4+=320;
  286.  
  287.      addq.w    #1,d3          ;         }
  288.      cmp.w     d3,d1
  289.      bne.s     gl_whld4
  290.  
  291.      move.w    d6,d2          ;       if(takeoff_d6)
  292.      beq.s     gl_skip2       ;         {
  293.      sub.w     #16,d2         ;           write_word_d7<<=(16-takeoff_d6);
  294. gl_shloop
  295.      add.w     d7,d7
  296.      addq.w    #1,d2
  297.      bne.s     gl_shloop
  298.      move.w    d7,(a0)        ;           *to_a0=write_word_d7;
  299.                               ;         }
  300. gl_skip2
  301.      lsr.w     #2,d1          ;     }
  302.      cmp.w     #80,d1
  303.      bne.s     gl_ford1
  304. gl_out                        ; }
  305.      movem.l   (SP)+,d2-d7
  306.      rts
  307.  
  308.  SECTION __MERGED,DATA,PUBLIC
  309. _SILVERFOX::
  310.      incbin    "bin/FOX1.slz2"
  311.      CNOP 0,2
  312.  
  313.   BSS, CHIP
  314. _NOMOUSE::
  315.           ds.l 3
  316. _BM0::    ds.b 32000
  317.  
  318.     END
  319.