home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / Kasumi / source / blt_reference_pal.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  11.5 KB  |  546 lines
  1. #include <vd2/system/vdtypes.h>
  2. #include <vd2/Kasumi/pixmap.h>
  3. #include <vd2/Kasumi/pixmaputils.h>
  4.  
  5. #define DECLARE_PALETTED(x, y) void VDPixmapBlt_##x##_to_##y##_reference(void *dst0, ptrdiff_t dstpitch, const void *src0, ptrdiff_t srcpitch, vdpixsize w, vdpixsize h, const void *pal0)
  6.  
  7. ///////////////////////////////////////////////////////////////////////////
  8. //
  9. //    RGB blitters: Pal1 ->
  10. //
  11. ///////////////////////////////////////////////////////////////////////////
  12.  
  13. DECLARE_PALETTED(Pal1, Any8) {
  14.     const uint8 *src = (const uint8 *)src0;
  15.     uint8 *dst = (uint8 *)dst0;
  16.     const uint8 *pal = (const uint8 *)pal0;
  17.  
  18.     src += (w-1) >> 3;
  19.     dst += (w-1) & ~7;
  20.  
  21.     srcpitch += (w+7) >> 3;
  22.     dstpitch += (w+7) & ~7;
  23.  
  24.     do {
  25.         int wt = w;
  26.  
  27.         uint8 v = src[0] >> ((-wt) & 7);
  28.         
  29.         switch(wt & 7) {
  30.             do {
  31.                 v = src[0];
  32.  
  33.         case 0:    dst[7] = pal[v&1];    v >>= 1;
  34.         case 7:    dst[6] = pal[v&1];    v >>= 1;
  35.         case 6:    dst[5] = pal[v&1];    v >>= 1;
  36.         case 5:    dst[4] = pal[v&1];    v >>= 1;
  37.         case 4:    dst[3] = pal[v&1];    v >>= 1;
  38.         case 3:    dst[2] = pal[v&1];    v >>= 1;
  39.         case 2:    dst[1] = pal[v&1];    v >>= 1;
  40.         case 1:    dst[0] = pal[v&1];    v >>= 1;
  41.  
  42.                 dst -= 8;
  43.                 --src;
  44.             } while((wt -= 8) > 0);
  45.         }
  46.  
  47.         vdptrstep(src, srcpitch);
  48.         vdptrstep(dst, dstpitch);
  49.     } while(--h);
  50. }
  51.  
  52. DECLARE_PALETTED(Pal1, Any16) {
  53.     const uint8 *src = (const uint8 *)src0;
  54.     uint16 *dst = (uint16 *)dst0;
  55.     const uint16 *pal = (const uint16 *)pal0;
  56.  
  57.     src += (w-1) >> 3;
  58.     dst += (w-1) & ~7;
  59.  
  60.     srcpitch += (w+7) >> 3;
  61.     dstpitch += ((w+7) & ~7) * 2;
  62.  
  63.     do {
  64.         int wt = w;
  65.  
  66.         uint8 v = src[0] >> ((-wt) & 7);
  67.         
  68.         switch(wt & 7) {
  69.             do {
  70.                 v = src[0];
  71.  
  72.         case 0:    dst[7] = pal[v&1];    v >>= 1;
  73.         case 7:    dst[6] = pal[v&1];    v >>= 1;
  74.         case 6:    dst[5] = pal[v&1];    v >>= 1;
  75.         case 5:    dst[4] = pal[v&1];    v >>= 1;
  76.         case 4:    dst[3] = pal[v&1];    v >>= 1;
  77.         case 3:    dst[2] = pal[v&1];    v >>= 1;
  78.         case 2:    dst[1] = pal[v&1];    v >>= 1;
  79.         case 1:    dst[0] = pal[v&1];    v >>= 1;
  80.  
  81.                 dst -= 8;
  82.                 --src;
  83.             } while((wt -= 8) > 0);
  84.         }
  85.  
  86.         vdptrstep(src, srcpitch);
  87.         vdptrstep(dst, dstpitch);
  88.     } while(--h);
  89. }
  90.  
  91. DECLARE_PALETTED(Pal1, Any24) {
  92.     const uint8 *src = (const uint8 *)src0;
  93.     uint8 *dst = (uint8 *)dst0;
  94.     const uint8 *pal = (const uint8 *)pal0;
  95.  
  96.     src += (w-1) >> 3;
  97.     dst += ((w-1) & ~7) * 3;
  98.  
  99.     srcpitch += (w+7) >> 3;
  100.     dstpitch += ((w+7) & ~7) * 3;
  101.  
  102.     do {
  103.         int wt = w;
  104.  
  105.         uint8 v = src[0] >> ((-wt) & 7);
  106.         const uint8 *pe;
  107.         
  108.         switch(wt & 7) {
  109.             do {
  110.                 v = src[0];
  111.  
  112.         case 0:    pe = &pal[3*(v&1)]; dst[7*3+0] = pe[0]; dst[7*3+1] = pe[1]; dst[7*3+2] = pe[2]; v >>= 1;
  113.         case 7:    pe = &pal[3*(v&1)]; dst[6*3+0] = pe[0]; dst[6*3+1] = pe[1]; dst[6*3+2] = pe[2]; v >>= 1;
  114.         case 6:    pe = &pal[3*(v&1)]; dst[5*3+0] = pe[0]; dst[5*3+1] = pe[1]; dst[5*3+2] = pe[2]; v >>= 1;
  115.         case 5:    pe = &pal[3*(v&1)]; dst[4*3+0] = pe[0]; dst[4*3+1] = pe[1]; dst[4*3+2] = pe[2]; v >>= 1;
  116.         case 4:    pe = &pal[3*(v&1)]; dst[3*3+0] = pe[0]; dst[3*3+1] = pe[1]; dst[3*3+2] = pe[2]; v >>= 1;
  117.         case 3:    pe = &pal[3*(v&1)]; dst[2*3+0] = pe[0]; dst[2*3+1] = pe[1]; dst[2*3+2] = pe[2]; v >>= 1;
  118.         case 2:    pe = &pal[3*(v&1)]; dst[1*3+0] = pe[0]; dst[1*3+1] = pe[1]; dst[1*3+2] = pe[2]; v >>= 1;
  119.         case 1:    pe = &pal[3*(v&1)]; dst[0*3+0] = pe[0]; dst[0*3+1] = pe[1]; dst[0*3+2] = pe[2]; v >>= 1;
  120.  
  121.                 dst -= 24;
  122.                 --src;
  123.             } while((wt -= 8) > 0);
  124.         }
  125.  
  126.         vdptrstep(src, srcpitch);
  127.         vdptrstep(dst, dstpitch);
  128.     } while(--h);
  129. }
  130.  
  131. DECLARE_PALETTED(Pal1, Any32) {
  132.     const uint8 *src = (const uint8 *)src0;
  133.     uint32 *dst = (uint32 *)dst0;
  134.     const uint32 *pal = (const uint32 *)pal0;
  135.  
  136.     src += (w-1) >> 3;
  137.     dst += (w-1) & ~7;
  138.  
  139.     srcpitch += (w+7) >> 3;
  140.     dstpitch += ((w+7) & ~7) * 4;
  141.  
  142.     do {
  143.         int wt = w;
  144.  
  145.         uint8 v = src[0] >> ((-wt) & 7);
  146.         
  147.         switch(wt & 7) {
  148.             do {
  149.                 v = src[0];
  150.  
  151.         case 0:    dst[7] = pal[v&1];    v >>= 1;
  152.         case 7:    dst[6] = pal[v&1];    v >>= 1;
  153.         case 6:    dst[5] = pal[v&1];    v >>= 1;
  154.         case 5:    dst[4] = pal[v&1];    v >>= 1;
  155.         case 4:    dst[3] = pal[v&1];    v >>= 1;
  156.         case 3:    dst[2] = pal[v&1];    v >>= 1;
  157.         case 2:    dst[1] = pal[v&1];    v >>= 1;
  158.         case 1:    dst[0] = pal[v&1];    v >>= 1;
  159.  
  160.                 dst -= 8;
  161.                 --src;
  162.             } while((wt -= 8) > 0);
  163.         }
  164.  
  165.         vdptrstep(src, srcpitch);
  166.         vdptrstep(dst, dstpitch);
  167.     } while(--h);
  168. }
  169.  
  170. ///////////////////////////////////////////////////////////////////////////
  171. //
  172. //    RGB blitters: Pal2 ->
  173. //
  174. ///////////////////////////////////////////////////////////////////////////
  175.  
  176. DECLARE_PALETTED(Pal2, Any8) {
  177.     const uint8 *src = (const uint8 *)src0;
  178.     uint8 *dst = (uint8 *)dst0;
  179.     const uint8 *pal = (const uint8 *)pal0;
  180.  
  181.     src += (w-1) >> 2;
  182.     dst += (w-1) & ~3;
  183.  
  184.     srcpitch += (w+3) >> 2;
  185.     dstpitch += (w+3) & ~3;
  186.  
  187.     do {
  188.         int wt = w;
  189.  
  190.         uint8 v = src[0] >> (((-wt) & 3)*2);
  191.         
  192.         switch(wt & 3) {
  193.             do {
  194.                 v = src[0];
  195.  
  196.         case 0:    dst[3] = pal[v&3];    v >>= 2;
  197.         case 3:    dst[2] = pal[v&3];    v >>= 2;
  198.         case 2:    dst[1] = pal[v&3];    v >>= 2;
  199.         case 1:    dst[0] = pal[v&3];    v >>= 2;
  200.  
  201.                 dst -= 4;
  202.                 --src;
  203.             } while((wt -= 4) > 0);
  204.         }
  205.  
  206.         vdptrstep(src, srcpitch);
  207.         vdptrstep(dst, dstpitch);
  208.     } while(--h);
  209. }
  210.  
  211. DECLARE_PALETTED(Pal2, Any16) {
  212.     const uint8 *src = (const uint8 *)src0;
  213.     uint16 *dst = (uint16 *)dst0;
  214.     const uint16 *pal = (const uint16 *)pal0;
  215.  
  216.     src += (w-1) >> 2;
  217.     dst += (w-1) & ~3;
  218.  
  219.     srcpitch += (w+3) >> 2;
  220.     dstpitch += ((w+3) & ~3) * 2;
  221.  
  222.     do {
  223.         int wt = w;
  224.  
  225.         uint8 v = src[0] >> (((-wt) & 3)*2);
  226.         
  227.         switch(wt & 3) {
  228.             do {
  229.                 v = src[0];
  230.  
  231.         case 0:    dst[3] = pal[v&3];    v >>= 2;
  232.         case 3:    dst[2] = pal[v&3];    v >>= 2;
  233.         case 2:    dst[1] = pal[v&3];    v >>= 2;
  234.         case 1:    dst[0] = pal[v&3];    v >>= 2;
  235.  
  236.                 dst -= 4;
  237.                 --src;
  238.             } while((wt -= 4) > 0);
  239.         }
  240.  
  241.         vdptrstep(src, srcpitch);
  242.         vdptrstep(dst, dstpitch);
  243.     } while(--h);
  244. }
  245.  
  246. DECLARE_PALETTED(Pal2, Any24) {
  247.     const uint8 *src = (const uint8 *)src0;
  248.     uint8 *dst = (uint8 *)dst0;
  249.     const uint8 *pal = (const uint8 *)pal0;
  250.  
  251.     src += (w-1) >> 2;
  252.     dst += ((w-1) & ~3) * 3;
  253.  
  254.     srcpitch += (w+3) >> 2;
  255.     dstpitch += ((w+3) & ~3) * 3;
  256.  
  257.     do {
  258.         int wt = w;
  259.  
  260.         uint8 v = src[0] >> (((-wt) & 3)*2);
  261.         const uint8 *pe;
  262.         
  263.         switch(wt & 3) {
  264.             do {
  265.                 v = src[0];
  266.  
  267.         case 0:    pe = &pal[3*(v&3)]; dst[3*3+0] = pe[0]; dst[3*3+1] = pe[1]; dst[3*3+2] = pe[2]; v >>= 2;
  268.         case 3:    pe = &pal[3*(v&3)]; dst[2*3+0] = pe[0]; dst[2*3+1] = pe[1]; dst[2*3+2] = pe[2]; v >>= 2;
  269.         case 2:    pe = &pal[3*(v&3)]; dst[1*3+0] = pe[0]; dst[1*3+1] = pe[1]; dst[1*3+2] = pe[2]; v >>= 2;
  270.         case 1:    pe = &pal[3*(v&3)]; dst[0*3+0] = pe[0]; dst[0*3+1] = pe[1]; dst[0*3+2] = pe[2]; v >>= 2;
  271.  
  272.                 dst -= 12;
  273.                 --src;
  274.             } while((wt -= 4) > 0);
  275.         }
  276.  
  277.         vdptrstep(src, srcpitch);
  278.         vdptrstep(dst, dstpitch);
  279.     } while(--h);
  280. }
  281.  
  282. DECLARE_PALETTED(Pal2, Any32) {
  283.     const uint8 *src = (const uint8 *)src0;
  284.     uint32 *dst = (uint32 *)dst0;
  285.     const uint32 *pal = (const uint32 *)pal0;
  286.  
  287.     src += (w-1) >> 2;
  288.     dst += (w-1) & ~3;
  289.  
  290.     srcpitch += (w+3) >> 2;
  291.     dstpitch += ((w+3) & ~3) * 4;
  292.  
  293.     do {
  294.         int wt = w;
  295.  
  296.         uint8 v = src[0] >> (((-wt) & 3)*2);
  297.         
  298.         switch(wt & 3) {
  299.             do {
  300.                 v = src[0];
  301.  
  302.         case 0:    dst[3] = pal[v&3];    v >>= 2;
  303.         case 3:    dst[2] = pal[v&3];    v >>= 2;
  304.         case 2:    dst[1] = pal[v&3];    v >>= 2;
  305.         case 1:    dst[0] = pal[v&3];    v >>= 2;
  306.  
  307.                 dst -= 4;
  308.                 --src;
  309.             } while((wt -= 4) > 0);
  310.         }
  311.  
  312.         vdptrstep(src, srcpitch);
  313.         vdptrstep(dst, dstpitch);
  314.     } while(--h);
  315. }
  316.  
  317. ///////////////////////////////////////////////////////////////////////////
  318. //
  319. //    RGB blitters: Pal4 ->
  320. //
  321. ///////////////////////////////////////////////////////////////////////////
  322.  
  323. DECLARE_PALETTED(Pal4, Any8) {
  324.     const uint8 *src = (const uint8 *)src0;
  325.     uint8 *dst = (uint8 *)dst0;
  326.     const uint8 *pal = (const uint8 *)pal0;
  327.  
  328.     src += (w-1) >> 1;
  329.     dst += ((w-1) & ~1);
  330.  
  331.     srcpitch += (w+1) >> 1;
  332.     dstpitch += (w+1) & ~1;
  333.  
  334.     do {
  335.         int wt = w;
  336.  
  337.         uint8 v = src[0] >> (((-wt) & 1)*4);
  338.         
  339.         switch(wt & 1) {
  340.             do {
  341.                 v = src[0];
  342.  
  343.         case 0:    dst[1] = pal[v&15];    v >>= 4;
  344.         case 1:    dst[0] = pal[v&15];    v >>= 4;
  345.  
  346.                 dst -= 2;
  347.                 --src;
  348.             } while((wt -= 2) > 0);
  349.         }
  350.  
  351.         vdptrstep(src, srcpitch);
  352.         vdptrstep(dst, dstpitch);
  353.     } while(--h);
  354. }
  355.  
  356. DECLARE_PALETTED(Pal4, Any16) {
  357.     const uint8 *src = (const uint8 *)src0;
  358.     uint16 *dst = (uint16 *)dst0;
  359.     const uint16 *pal = (const uint16 *)pal0;
  360.  
  361.     src += (w-1) >> 1;
  362.     dst += ((w-1) & ~1);
  363.  
  364.     srcpitch += (w+1) >> 1;
  365.     dstpitch += ((w+1) & ~1) * 2;
  366.  
  367.     do {
  368.         int wt = w;
  369.  
  370.         uint8 v = src[0] >> (((-wt) & 1)*4);
  371.         
  372.         switch(wt & 1) {
  373.             do {
  374.                 v = src[0];
  375.  
  376.         case 0:    dst[1] = pal[v&15];    v >>= 4;
  377.         case 1:    dst[0] = pal[v&15];    v >>= 4;
  378.  
  379.                 dst -= 2;
  380.                 --src;
  381.             } while((wt -= 2) > 0);
  382.         }
  383.  
  384.         vdptrstep(src, srcpitch);
  385.         vdptrstep(dst, dstpitch);
  386.     } while(--h);
  387. }
  388.  
  389. DECLARE_PALETTED(Pal4, Any24) {
  390.     const uint8 *src = (const uint8 *)src0;
  391.     uint8 *dst = (uint8 *)dst0;
  392.     const uint8 *pal = (const uint8 *)pal0;
  393.  
  394.     src += (w-1) >> 1;
  395.     dst += ((w-1) & ~1) * 3;
  396.  
  397.     srcpitch += (w+1) >> 1;
  398.     dstpitch += ((w+1) & ~1) * 3;
  399.  
  400.     do {
  401.         int wt = w;
  402.  
  403.         uint8 v = src[0] >> (((-wt) & 1)*4);
  404.         const uint8 *pe;
  405.         
  406.         switch(wt & 1) {
  407.             do {
  408.                 v = src[0];
  409.  
  410.         case 0:    pe = &pal[3*(v&15)]; dst[1*3+0] = pe[0]; dst[1*3+1] = pe[1]; dst[1*3+2] = pe[2]; v >>= 4;
  411.         case 1:    pe = &pal[3*(v&15)]; dst[0*3+0] = pe[0]; dst[0*3+1] = pe[1]; dst[0*3+2] = pe[2]; v >>= 4;
  412.  
  413.                 dst -= 6;
  414.                 --src;
  415.             } while((wt -= 2) > 0);
  416.         }
  417.  
  418.         vdptrstep(src, srcpitch);
  419.         vdptrstep(dst, dstpitch);
  420.     } while(--h);
  421. }
  422.  
  423. DECLARE_PALETTED(Pal4, Any32) {
  424.     const uint8 *src = (const uint8 *)src0;
  425.     uint32 *dst = (uint32 *)dst0;
  426.     const uint32 *pal = (const uint32 *)pal0;
  427.  
  428.     src += (w-1) >> 1;
  429.     dst += ((w-1) & ~1);
  430.  
  431.     srcpitch += (w+1) >> 1;
  432.     dstpitch += ((w+1) & ~1) * 4;
  433.  
  434.     do {
  435.         int wt = w;
  436.  
  437.         uint8 v = src[0] >> (((-wt) & 1)*4);
  438.         
  439.         switch(wt & 1) {
  440.             do {
  441.                 v = src[0];
  442.  
  443.         case 0:    dst[1] = pal[v&15];    v >>= 4;
  444.         case 1:    dst[0] = pal[v&15];    v >>= 4;
  445.  
  446.                 dst -= 2;
  447.                 --src;
  448.             } while((wt -= 2) > 0);
  449.         }
  450.  
  451.         vdptrstep(src, srcpitch);
  452.         vdptrstep(dst, dstpitch);
  453.     } while(--h);
  454. }
  455.  
  456. ///////////////////////////////////////////////////////////////////////////
  457. //
  458. //    RGB blitters: Pal8 ->
  459. //
  460. ///////////////////////////////////////////////////////////////////////////
  461.  
  462. DECLARE_PALETTED(Pal8, Any8) {
  463.     const uint8 *src = (const uint8 *)src0;
  464.     uint8 *dst = (uint8 *)dst0;
  465.     const uint8 *pal = (const uint8 *)pal0;
  466.  
  467.     srcpitch -= w;
  468.     dstpitch -= w;
  469.  
  470.     do {
  471.         int wt = w;
  472.  
  473.         do {
  474.             *dst++ = pal[*src++];
  475.         } while(--wt);
  476.  
  477.         vdptrstep(src, srcpitch);
  478.         vdptrstep(dst, dstpitch);
  479.     } while(--h);
  480. }
  481.  
  482. DECLARE_PALETTED(Pal8, Any16) {
  483.     const uint8 *src = (const uint8 *)src0;
  484.     uint16 *dst = (uint16 *)dst0;
  485.     const uint16 *pal = (const uint16 *)pal0;
  486.  
  487.     srcpitch -= w;
  488.     dstpitch -= w*2;
  489.  
  490.     do {
  491.         int wt = w;
  492.  
  493.         do {
  494.             *dst++ = pal[*src++];
  495.         } while(--wt);
  496.  
  497.         vdptrstep(src, srcpitch);
  498.         vdptrstep(dst, dstpitch);
  499.     } while(--h);
  500. }
  501.  
  502. DECLARE_PALETTED(Pal8, Any24) {
  503.     const uint8 *src = (const uint8 *)src0;
  504.     uint8 *dst = (uint8 *)dst0;
  505.     const uint8 *pal = (const uint8 *)pal0;
  506.  
  507.     srcpitch -= w;
  508.     dstpitch -= w*3;
  509.  
  510.     do {
  511.         int wt = w;
  512.         do {
  513.             const uint8 *pe = &pal[3**src++];
  514.  
  515.             dst[0] = pe[0];
  516.             dst[1] = pe[1];
  517.             dst[2] = pe[2];
  518.             dst += 3;
  519.         } while(--wt);
  520.  
  521.         vdptrstep(src, srcpitch);
  522.         vdptrstep(dst, dstpitch);
  523.     } while(--h);
  524. }
  525.  
  526. DECLARE_PALETTED(Pal8, Any32) {
  527.     const uint8 *src = (const uint8 *)src0;
  528.     uint32 *dst = (uint32 *)dst0;
  529.     const uint32 *pal = (const uint32 *)pal0;
  530.  
  531.     srcpitch -= w;
  532.     dstpitch -= w*4;
  533.  
  534.     do {
  535.         int wt = w;
  536.  
  537.         do {
  538.             *dst++ = pal[*src++];
  539.         } while(--wt);
  540.  
  541.         vdptrstep(src, srcpitch);
  542.         vdptrstep(dst, dstpitch);
  543.     } while(--h);
  544. }
  545.  
  546.