home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quake_src / vid_c2p_040.s < prev    next >
Text File  |  2000-06-17  |  12KB  |  578 lines
  1. * 
  2. * Copyright (C) 1996-1997 Id Software, Inc. 
  3. * 
  4. * This program is free software; you can redistribute it and/or 
  5. * modify it under the terms of the GNU General Public License 
  6. * as published by the Free Software Foundation; either version 2 
  7. * of the License, or (at your option) any later version. 
  8. * 
  9. * This program is distributed in the hope that it will be useful, 
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of 
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   
  12. * 
  13. * See the GNU General Public License for more details. 
  14. * 
  15. * You should have received a copy of the GNU General Public License 
  16. * along with this program; if not, write to the Free Software 
  17. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  18. * 
  19.  
  20.     mc68020
  21.  
  22.     IFD    depth8
  23. depth    set    8
  24.     ENDC
  25.     IFD    depth6
  26. depth    set    6
  27.     ENDC
  28.  
  29. ; Chunky2Planar algorithm, originally by James McCoull
  30. ; Modified by Peter McGavin for variable size and depth
  31. ; and "compare buffer" (hope I didn't slow it down too much)
  32. ;
  33. ; 09-Jan-98 svent
  34. ;           Longword alignment for stack
  35. ;
  36. ;     Cpu only solution VERSION 2
  37. ;    Optimised for 040+fastram
  38. ;    bitplanes are assumed contiguous!
  39. ;    analyse instruction offsets to check performance
  40.  
  41. ;void __asm c2p_6_040 (register __a0 UBYTE *chunky_data,
  42. ;                      register __a1 PLANEPTR raster,
  43. ;                      register __a2 UBYTE *compare_buffer,
  44. ;                      register __a4 UBYTE *xlate,
  45. ;                      register __d1 ULONG plsiz,
  46. ;                      register __d2 BOOL force_update);
  47.  
  48. ;void __asm c2p_8_040 (register __a0 UBYTE *chunky_data,
  49. ;                      register __a1 PLANEPTR raster,
  50. ;                      register __a2 UBYTE *compare_buffer,
  51. ;                      register __d1 ULONG plsiz);
  52.  
  53. ; a0 -> width*height chunky pixels
  54. ; a1 -> contiguous bitplanes
  55. ; a2 -> compare buffer
  56. ; d1 = width*height/8   (width*height must be a multiple of 32)
  57.  
  58.  
  59.     ifeq    depth-8
  60.         xdef    _c2p_8_040
  61. _c2p_8_040:
  62.     else
  63.     ifeq    depth-6
  64.         xdef    _c2p_6_040
  65. _c2p_6_040:
  66.     else
  67.         fail    "unsupported depth!"
  68.     endc
  69.     endc
  70.  
  71. merge        macro ; in1,in2,tmp3,tmp4,mask,shift
  72. ; \1 = abqr
  73. ; \2 = ijyz
  74.         move.l    \2,\4
  75.         move.l    #\5,\3
  76.         and.l    \3,\2    ; \2 = 0j0z
  77.         and.l    \1,\3    ; \3 = 0b0r
  78.         eor.l    \3,\1    ; \1 = a0q0
  79.         eor.l    \2,\4    ; \4 = i0y0
  80.         ifeq    \6-1
  81.         add.l    \3,\3
  82.         else
  83.         lsl.l    #\6,\3    ; \3 = b0r0
  84.         endc
  85.         lsr.l    #\6,\4    ; \4 = 0i0y
  86.         or.l    \3,\2    ; \2 = bjrz
  87.         or.l    \4,\1    ; \1 = aiqy
  88.         endm
  89.  
  90. xlate        macro    ; translate 4 8-bit pixels to 6-bit EHB
  91.         move.b    (\1,a0),d7
  92.         move.b    (a4,d7.w),\2
  93.         lsl.w    #8,\2
  94.         move.b    (\1+8,a0),d7
  95.         move.b    (a4,d7.w),\2
  96.         swap    \2
  97.         move.b    (\1+16,a0),d7
  98.         move.b    (a4,d7.w),\2
  99.         lsl.w    #8,\2
  100.         move.b    (\1+24,a0),d7
  101.         move.b    (a4,d7.w),\2
  102.         endm
  103.  
  104. start:        movem.l    d2-d7/a2-a6,-(sp)
  105.  
  106.         sub.w    #48,sp        ; space for temporary variables
  107.  
  108.     ifle depth-6
  109.         move.w    d2,(44,sp)    ; video_force_update
  110.     endc
  111.  
  112. ; a0 = chunky buffer
  113. ; a1 = output area
  114. ; a2 = compare buffer
  115. ; d1 = plsiz
  116.  
  117.         movea.l    d1,a3        ; a3 = plsiz
  118.  
  119.         move.l    a0,(40,sp)
  120.         lsl.l    #3,d1
  121.         add.l    d1,(40,sp)    ; (40,sp) -> end of chunky data
  122.  
  123. first_loop:
  124.     ifle depth-6
  125.         tst.w    (44,sp)        ; force_update?
  126.         bne.b    first_case
  127.     endc
  128.         cmpm.l    (a0)+,(a2)+
  129.         bne.b    stub1
  130.         cmpm.l    (a0)+,(a2)+
  131.         bne.b    stub2
  132.         cmpm.l    (a0)+,(a2)+
  133.         bne.b    stub3
  134.         cmpm.l    (a0)+,(a2)+
  135.         bne.b    stub4
  136.         cmpm.l    (a0)+,(a2)+
  137.         bne.b    stub5
  138.         cmpm.l    (a0)+,(a2)+
  139.         bne.b    stub6
  140.         cmpm.l    (a0)+,(a2)+
  141.         bne.b    stub7
  142.         cmpm.l    (a0)+,(a2)+
  143.         bne.b    stub8
  144.  
  145.         addq.l    #4,a1        ; skip 32 pixels on output
  146.  
  147.         cmpa.l    (40,sp),a0
  148.         bcs.b    first_loop
  149.         bra.w    exit        ; exit if no changes found
  150.  
  151. stub8:        subq.l    #4,a0
  152.         subq.l    #4,a2
  153. stub7:        subq.l    #4,a0
  154.         subq.l    #4,a2
  155. stub6:        subq.l    #4,a0
  156.         subq.l    #4,a2
  157. stub5:        subq.l    #4,a0
  158.         subq.l    #4,a2
  159. stub4:        subq.l    #4,a0
  160.         subq.l    #4,a2
  161. stub3:        subq.l    #4,a0
  162.         subq.l    #4,a2
  163. stub2:        subq.l    #4,a0
  164.         subq.l    #4,a2
  165. stub1:        subq.l    #4,a0
  166.         subq.l    #4,a2
  167.  
  168. first_case:
  169.     ifgt depth-6        ; depth 8 code --- no need to xlate pixels
  170.         move.l    (0,a0),d1
  171.          move.l    (4,a0),d3
  172.         move.l    (8,a0),d0
  173.         move.l    (12,a0),d2
  174.         move.l    (2,a0),d4
  175.          move.l    (10,a0),d5
  176.         move.l    (6,a0),d6
  177.         move.l    (14,a0),d7
  178.  
  179.         move.l    d1,(0,a2)
  180.         move.l    d3,(4,a2)
  181.         move.l    d0,(8,a2)
  182.         move.l    d2,(12,a2)
  183.  
  184.          move.w    (16,a0),d1
  185.          move.w    (24,a0),d0
  186.         move.w    (20,a0),d3
  187.         move.w    (28,a0),d2
  188.          move.w    (18,a0),d4
  189.          move.w    (26,a0),d5
  190.         move.w    (22,a0),d6
  191.         move.w    (30,a0),d7
  192.  
  193.          move.w    d1,(16,a2)
  194.          move.w    d0,(24,a2)
  195.         move.w    d3,(20,a2)
  196.         move.w    d2,(28,a2)
  197.          move.w    d4,(18,a2)
  198.          move.w    d5,(26,a2)
  199.         move.w    d6,(22,a2)
  200.         move.w    d7,(30,a2)
  201.  
  202.         move.l    d6,a5
  203.         move.l    d7,a6
  204.  
  205.         merge    d1,d0,d6,d7,$00ff00ff,8
  206.         merge    d3,d2,d6,d7,$00ff00ff,8
  207.  
  208.         merge    d1,d3,d6,d7,$0f0f0f0f,4    
  209.         merge    d0,d2,d6,d7,$0f0f0f0f,4
  210.  
  211.         exg    d1,a5
  212.         exg    d0,a6
  213.  
  214.         merge    d4,d5,d6,d7,$00ff00ff,8
  215.         merge    d1,d0,d6,d7,$00ff00ff,8
  216.  
  217.         merge    d4,d1,d6,d7,$0f0f0f0f,4
  218.         merge    d5,d0,d6,d7,$0f0f0f0f,4
  219.  
  220.         merge    d3,d1,d6,d7,$33333333,2
  221.         merge    d2,d0,d6,d7,$33333333,2    
  222.  
  223.         merge    d3,d2,d6,d7,$55555555,1
  224.         merge    d1,d0,d6,d7,$55555555,1
  225.  
  226.         move.l    d0,(0*4,sp)        ;plane0 (movem.l is slower!)
  227.         move.l    d1,(1*4,sp)        ;plane1
  228.         move.l    d2,(2*4,sp)        ;plane2
  229.         move.l    d3,(3*4,sp)        ;plane3
  230.  
  231.         move.l    a5,d3
  232.         move.l    a6,d2
  233.  
  234.         merge    d3,d4,d6,d7,$33333333,2
  235.         merge    d2,d5,d6,d7,$33333333,2
  236.  
  237.         merge    d3,d2,d6,d7,$55555555,1
  238.         merge    d4,d5,d6,d7,$55555555,1
  239.  
  240.         move.l    d5,(4*4,sp)        ;plane4
  241.         move.l    d4,(5*4,sp)        ;plane5
  242.  
  243.         move.l    d2,(6*4,sp)        ;plane6
  244.         move.l    d3,(7*4,sp)        ;plane7
  245.  
  246.     else            ; depth 6 code, xlate from 8-bit to 6-bit EHB
  247.         moveq    #0,d7
  248.  
  249.         move.l    (a0),(a2)    ; copy to compare buffer
  250.         move.l    (4,a0),(4,a2)
  251.         move.l    (8,a0),(8,a2)
  252.         move.l    (12,a0),(12,a2)
  253.         move.l    (16,a0),(16,a2)
  254.         move.l    (20,a0),(20,a2)
  255.         move.l    (24,a0),(24,a2)
  256.         move.l    (28,a0),(28,a2)
  257.  
  258.         xlate    0,d1        ; does 8-bit to EHB colour translate
  259.         xlate    1,d0        ; 4 pixels at a time
  260.         xlate    4,d3
  261.         xlate    5,d2
  262.  
  263.         merge    d1,d3,d6,d7,$0f0f0f0f,4    
  264.         merge    d0,d2,d6,d7,$0f0f0f0f,4
  265.  
  266.         movea.l    d1,a5
  267.         movea.l    d0,a6
  268.  
  269.         moveq    #0,d7
  270.  
  271.         xlate    2,d4
  272.         xlate    3,d5
  273.         xlate    6,d1
  274.         xlate    7,d0
  275.  
  276.         merge    d4,d1,d6,d7,$0f0f0f0f,4
  277.         merge    d5,d0,d6,d7,$0f0f0f0f,4
  278.  
  279.         merge    d3,d1,d6,d7,$33333333,2
  280.         merge    d2,d0,d6,d7,$33333333,2    
  281.  
  282.         merge    d3,d2,d6,d7,$55555555,1
  283.         merge    d1,d0,d6,d7,$55555555,1
  284.  
  285.         move.l    d0,(0*4,sp)        ;plane0 (movem.l is slower!)
  286.         move.l    d1,(1*4,sp)        ;plane1
  287.         move.l    d2,(2*4,sp)        ;plane2
  288.         move.l    d3,(3*4,sp)        ;plane3
  289.  
  290.         move.l    a5,d3
  291.         move.l    a6,d2
  292.  
  293.         merge    d3,d4,d6,d7,$33333333,2
  294.         merge    d2,d5,d6,d7,$33333333,2
  295.  
  296.         merge    d4,d5,d6,d7,$55555555,1
  297.  
  298.         move.l    d5,(4*4,sp)        ;plane4
  299.         move.l    d4,(5*4,sp)        ;plane5
  300.  
  301.     endc
  302.  
  303.         adda.w    #32,a0
  304.         adda.w    #32,a2
  305.  
  306.         move.l    a1,(32,sp)        ; save output address
  307.         addq.l    #4,a1            ; skip 32 pixels on output
  308.  
  309.         cmpa.l    (40,sp),a0
  310.         bcc.w    final_case
  311.  
  312.  
  313. main_loop:
  314.     ifle depth-6
  315.         tst.w    (44,sp)        ; force_update?
  316.         bne.b    main_case
  317.     endc
  318.         cmpm.l    (a0)+,(a2)+    ; compare next 32 pixels
  319.         bne.b    mstub1
  320.         cmpm.l    (a0)+,(a2)+
  321.         bne.b    mstub2
  322.         cmpm.l    (a0)+,(a2)+
  323.         bne.b    mstub3
  324.         cmpm.l    (a0)+,(a2)+
  325.         bne.b    mstub4
  326.         cmpm.l    (a0)+,(a2)+
  327.         bne.b    mstub5
  328.         cmpm.l    (a0)+,(a2)+
  329.         bne.b    mstub6
  330.         cmpm.l    (a0)+,(a2)+
  331.         bne.b    mstub7
  332.         cmpm.l    (a0)+,(a2)+
  333.         bne.b    mstub8
  334.  
  335.         addq.l    #4,a1        ; skip 32 pixels on output
  336.  
  337.         cmpa.l    (40,sp),a0
  338.         bcs.b    main_loop
  339.         bra.w    final_case    ; exit if no more changes found
  340.  
  341. mstub8:        subq.l    #4,a0
  342.         subq.l    #4,a2
  343. mstub7:        subq.l    #4,a0
  344.         subq.l    #4,a2
  345. mstub6:        subq.l    #4,a0
  346.         subq.l    #4,a2
  347. mstub5:        subq.l    #4,a0
  348.         subq.l    #4,a2
  349. mstub4:        subq.l    #4,a0
  350.         subq.l    #4,a2
  351. mstub3:        subq.l    #4,a0
  352.         subq.l    #4,a2
  353. mstub2:        subq.l    #4,a0
  354.         subq.l    #4,a2
  355. mstub1:        subq.l    #4,a0
  356.         subq.l    #4,a2
  357.  
  358. main_case:    move.l    a1,(36,sp)    ; save current output address
  359.         move.l    (32,sp),a1    ; a1 = previous output address
  360.  
  361.     ifgt depth-6
  362.         move.l    (0,a0),d1
  363.          move.l    (4,a0),d3
  364.          move.l    (8,a0),d0
  365.         move.l    (12,a0),d2
  366.         move.l    (2,a0),d4
  367.          move.l    (10,a0),d5
  368.         move.l    (6,a0),d6
  369.         move.l    (14,a0),d7
  370.  
  371.         move.l    d1,(0,a2)
  372.         move.l    d3,(4,a2)
  373.         move.l    d0,(8,a2)
  374.         move.l    d2,(12,a2)
  375.  
  376.          move.w    (16,a0),d1
  377.          move.w    (24,a0),d0
  378.         move.w    (20,a0),d3
  379.         move.w    (28,a0),d2
  380.          move.w    (18,a0),d4
  381.          move.w    (26,a0),d5
  382.         move.w    (22,a0),d6
  383.         move.w    (30,a0),d7
  384.  
  385.          move.w    d1,(16,a2)
  386.          move.w    d0,(24,a2)
  387.         move.w    d3,(20,a2)
  388.         move.w    d2,(28,a2)
  389.          move.w    d4,(18,a2)
  390.          move.w    d5,(26,a2)
  391.         move.w    d6,(22,a2)
  392.         move.w    d7,(30,a2)
  393.  
  394.         move.l    d6,a5
  395.         move.l    d7,a6
  396.  
  397.         move.l    (0*4,sp),(a1)        ;plane0
  398.         adda.l    a3,a1            ;a1+=plsiz
  399.  
  400.         merge    d1,d0,d6,d7,$00ff00ff,8
  401.         merge    d3,d2,d6,d7,$00ff00ff,8
  402.  
  403.         move.l    (1*4,sp),(a1)        ;plane1
  404.         adda.l    a3,a1            ;a1+=plsiz
  405.  
  406.         merge    d1,d3,d6,d7,$0f0f0f0f,4    
  407.         merge    d0,d2,d6,d7,$0f0f0f0f,4
  408.  
  409.         exg    d1,a5
  410.         exg    d0,a6
  411.  
  412.         move.l    (2*4,sp),(a1)        ;plane2
  413.         adda.l    a3,a1            ;a1+=plsiz
  414.  
  415.         merge    d4,d5,d6,d7,$00ff00ff,8
  416.         merge    d1,d0,d6,d7,$00ff00ff,8
  417.  
  418.         move.l    (3*4,sp),(a1)        ;plane3
  419.         adda.l    a3,a1            ;a1+=plsiz
  420.  
  421.         merge    d4,d1,d6,d7,$0f0f0f0f,4
  422.         merge    d5,d0,d6,d7,$0f0f0f0f,4
  423.  
  424.         move.l    (4*4,sp),(a1)        ;plane4
  425.         adda.l    a3,a1            ;a1+=plsiz
  426.  
  427.         merge    d3,d1,d6,d7,$33333333,2
  428.         merge    d2,d0,d6,d7,$33333333,2    
  429.  
  430.         move.l    (5*4,sp),(a1)        ;plane5
  431.         adda.l    a3,a1            ;a1+=plsiz
  432.  
  433.         merge    d3,d2,d6,d7,$55555555,1
  434.         merge    d1,d0,d6,d7,$55555555,1
  435.  
  436.         move.l    d0,(0*4,sp)        ;plane0 (movem.l is slower!)
  437.         move.l    d1,(1*4,sp)        ;plane1
  438.         move.l    d2,(2*4,sp)        ;plane2
  439.         move.l    d3,(3*4,sp)        ;plane3
  440.  
  441.         move.l    a5,d3
  442.         move.l    a6,d2
  443.  
  444.         move.l    (6*4,sp),(a1)        ;plane6
  445.         adda.l    a3,a1            ;a1+=plsiz
  446.  
  447.         merge    d3,d4,d6,d7,$33333333,2
  448.         merge    d2,d5,d6,d7,$33333333,2
  449.  
  450.         move.l    (7*4,sp),(a1)        ;plane7
  451.         adda.l    a3,a1            ;a1+=plsiz
  452.  
  453.         merge    d3,d2,d6,d7,$55555555,1
  454.         merge    d4,d5,d6,d7,$55555555,1
  455.  
  456.         move.l    d5,(4*4,sp)        ;plane4
  457.         move.l    d4,(5*4,sp)        ;plane5
  458.  
  459.         move.l    d2,(6*4,sp)        ;plane6
  460.         move.l    d3,(7*4,sp)        ;plane7
  461.  
  462.     else            ; depth 6 code, xlate from 8-bit to 6-bit EHB
  463.         moveq    #0,d7
  464.  
  465.         move.l    (a0),(a2)
  466.         move.l    (4,a0),(4,a2)
  467.         move.l    (8,a0),(8,a2)
  468.         move.l    (12,a0),(12,a2)
  469.         move.l    (16,a0),(16,a2)
  470.         move.l    (20,a0),(20,a2)
  471.         move.l    (24,a0),(24,a2)
  472.         move.l    (28,a0),(28,a2)
  473.  
  474.         xlate    0,d1        ; does 8-bit to EHB colour translate
  475.         xlate    1,d0        ; 4 pixels at a time
  476.         xlate    4,d3
  477.         xlate    5,d2
  478.  
  479.         move.l    (0*4,sp),(a1)        ;plane0
  480.         adda.l    a3,a1            ;a1+=plsiz
  481.  
  482.         merge    d1,d3,d6,d7,$0f0f0f0f,4    
  483.         merge    d0,d2,d6,d7,$0f0f0f0f,4
  484.  
  485.         movea.l    d1,a5
  486.         movea.l    d0,a6
  487.  
  488.         moveq    #0,d7
  489.  
  490.         xlate    2,d4
  491.         xlate    3,d5
  492.         xlate    6,d1
  493.         xlate    7,d0
  494.  
  495.         move.l    (1*4,sp),(a1)        ;plane1
  496.         adda.l    a3,a1            ;a1+=plsiz
  497.  
  498.         merge    d4,d1,d6,d7,$0f0f0f0f,4
  499.         merge    d5,d0,d6,d7,$0f0f0f0f,4
  500.  
  501.         move.l    (2*4,sp),(a1)        ;plane2
  502.         adda.l    a3,a1            ;a1+=plsiz
  503.  
  504.         merge    d3,d1,d6,d7,$33333333,2
  505.         merge    d2,d0,d6,d7,$33333333,2    
  506.  
  507.         move.l    (3*4,sp),(a1)        ;plane3
  508.         adda.l    a3,a1            ;a1+=plsiz
  509.  
  510.         merge    d3,d2,d6,d7,$55555555,1
  511.         merge    d1,d0,d6,d7,$55555555,1
  512.  
  513.         move.l    d0,(0*4,sp)        ;plane0 (movem.l is slower!)
  514.         move.l    d1,(1*4,sp)        ;plane1
  515.         move.l    d2,(2*4,sp)        ;plane2
  516.         move.l    d3,(3*4,sp)        ;plane3
  517.  
  518.         move.l    (4*4,sp),(a1)        ;plane4
  519.         adda.l    a3,a1            ;a1+=plsiz
  520.  
  521.         move.l    a5,d3
  522.         move.l    a6,d2
  523.  
  524.         merge    d3,d4,d6,d7,$33333333,2
  525.  
  526.         move.l    (5*4,sp),(a1)        ;plane5
  527.         adda.l    a3,a1            ;a1+=plsiz
  528.  
  529.         merge    d2,d5,d6,d7,$33333333,2
  530.  
  531.         merge    d4,d5,d6,d7,$55555555,1
  532.  
  533.         move.l    d5,(4*4,sp)        ;plane4
  534.         move.l    d4,(5*4,sp)        ;plane5
  535.  
  536.     endc
  537.  
  538.         adda.w    #32,a0
  539.         adda.w    #32,a2
  540.  
  541.         movea.l    (36,sp),a1    ; restore current output address
  542.         move.l    a1,(32,sp)    ; save output address
  543.  
  544.         addq.l    #4,a1        ; skip 32 pixels on output
  545.  
  546.         cmpa.l    (40,sp),a0
  547.         bcs.w    main_loop
  548.  
  549.  
  550. final_case:    move.l    (32,sp),a1    ; a1 = previous output address
  551.  
  552.         move.l    (0*4,sp),(a1)        ;plane0
  553.         adda.l    a3,a1            ;a1+=plsiz
  554.         move.l    (1*4,sp),(a1)         ;plane1
  555.         adda.l    a3,a1            ;a1+=plsiz
  556.         move.l    (2*4,sp),(a1)        ;plane2
  557.         adda.l    a3,a1            ;a1+=plsiz
  558.         move.l    (3*4,sp),(a1)        ;plane3
  559.         adda.l    a3,a1            ;a1+=plsiz
  560.         move.l    (4*4,sp),(a1)        ;plane4    
  561.         adda.l    a3,a1            ;a1+=plsiz
  562.         move.l    (5*4,sp),(a1)        ;plane5
  563.     ifgt depth-6
  564.         adda.l    a3,a1            ;a1+=plsiz
  565.         move.l    (6*4,sp),(a1)        ;plane6
  566.         adda.l    a3,a1            ;a1+=plsiz
  567.         move.l    (7*4,sp),(a1)        ;plane7
  568.     endc
  569.  
  570. exit:        add.w    #48,sp
  571.         movem.l    (sp)+,d2-d7/a2-a6
  572.         rts
  573.  
  574.         cnop    0,4
  575. end:
  576.  
  577.         end
  578.