16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26
27
28 /*
29 * The functions step along the lines from xLeft to xRight and apply
30 * the bilinear filtering.
31 *
32 */
33
34 #include "vis_proto.h"
35 #include "mlib_image.h"
36 #include "mlib_ImageColormap.h"
37 #include "mlib_ImageCopy.h"
38 #include "mlib_ImageAffine.h"
39 #include "mlib_v_ImageFilters.h"
40 #include "mlib_v_ImageChannelExtract.h"
41
42 /*#define MLIB_VIS2*/
43
44 /***************************************************************/
45 #define DTYPE mlib_s16
46
47 #define FUN_NAME(CHAN) mlib_ImageAffine_s16_##CHAN##_bl
48
49 /***************************************************************/
50 static mlib_status FUN_NAME(2ch_na)(mlib_affine_param *param);
51 static mlib_status FUN_NAME(4ch_na)(mlib_affine_param *param);
52
53 /***************************************************************/
54 const mlib_u64 mlib_dmask_arr[] = {
55 0x0000000000000000, 0x000000000000FFFF, 0x00000000FFFF0000, 0x00000000FFFFFFFF,
56 0x0000FFFF00000000, 0x0000FFFF0000FFFF, 0x0000FFFFFFFF0000, 0x0000FFFFFFFFFFFF,
689 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 8*(X >> MLIB_SHIFT);
690
691 vis_alignaddr(sp, 0);
692 sp0 = AL_ADDR(sp, 0);
693 s0 = vis_faligndata(sp0[0], sp0[1]);
694 s1 = vis_faligndata(sp0[1], sp0[2]);
695
696 vis_alignaddr(sp, srcYStride);
697 sp1 = AL_ADDR(sp, srcYStride);
698 s2 = vis_faligndata(sp1[0], sp1[1]);
699 s3 = vis_faligndata(sp1[1], sp1[2]);
700
701 BL_SUM();
702
703 pbuff[i] = dd;
704 X += dX;
705 Y += dY;
706 }
707
708 mlib_ImageCopy_na((mlib_u8*)pbuff, dl, 8*size);
709 }
710
711 if (pbuff != buff) {
712 mlib_free(pbuff);
713 }
714
715 return MLIB_SUCCESS;
716 }
717
718 /***************************************************************/
719 #define LUT(x) plut[x]
720
721 mlib_status FUN_NAME(s16_i)(mlib_affine_param *param,
722 const void *colormap)
723 {
724 DECLAREVAR();
725 mlib_s32 nchan = mlib_ImageGetLutChannels(colormap);
726 mlib_s32 lut_off = mlib_ImageGetLutOffset(colormap);
727 mlib_d64 *plut = (mlib_d64*)mlib_ImageGetLutNormalTable(colormap) - lut_off;
728 mlib_s32 max_xsize = param -> max_xsize;
729 mlib_d64 buff[BUF_SIZE], *pbuff = buff;
730
731 srcYStride /= sizeof(DTYPE);
732
733 if (max_xsize > BUF_SIZE) {
734 pbuff = mlib_malloc(max_xsize*sizeof(mlib_d64));
735
736 if (pbuff == NULL) return MLIB_FAILURE;
737 }
738
739 dX = (dX - (dX >> 31)) &~ 1; /* rounding towards ZERO */
740 dY = (dY - (dY >> 31)) &~ 1; /* rounding towards ZERO */
741 dx64 = vis_to_double_dup((((dX >> 1) & 0xFFFF) << 16) | ((dX >> 1) & 0xFFFF));
742 dy64 = vis_to_double_dup((((dY >> 1) & 0xFFFF) << 16) | ((dY >> 1) & 0xFFFF));
743
744 for (j = yStart; j <= yFinish; j++) {
745 DTYPE *sp;
746
747 NEW_LINE(1);
748
749 deltax = DOUBLE_4U16(X, X, X, X);
750 deltay = DOUBLE_4U16(Y, Y, Y, Y);
751
752 #pragma pipeloop(0)
753 for (i = 0; i < size; i++) {
754 sp = *(DTYPE**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT);
755 s0 = LUT(sp[0]);
756 s1 = LUT(sp[1]);
757 s2 = LUT(sp[srcYStride]);
758 s3 = LUT(sp[srcYStride + 1]);
759
760 BL_SUM();
761
762 pbuff[i] = dd;
763 X += dX;
764 Y += dY;
765 }
766
767 if (nchan == 3) {
768 mlib_ImageColorTrue2IndexLine_S16_S16_3_in_4((void*)pbuff, (void*)dl, size, colormap);
769 } else {
770 mlib_ImageColorTrue2IndexLine_S16_S16_4((void*)pbuff, (void*)dl, size, colormap);
771 }
772 }
773
774 if (pbuff != buff) {
775 mlib_free(pbuff);
776 }
777
778 return MLIB_SUCCESS;
779 }
780
781 /***************************************************************/
782 #undef DTYPE
783 #define DTYPE mlib_u8
784
785 mlib_status FUN_NAME(u8_i)(mlib_affine_param *param,
786 const void *colormap)
787 {
788 DECLAREVAR();
789 mlib_s32 nchan = mlib_ImageGetLutChannels(colormap);
790 mlib_s32 lut_off = mlib_ImageGetLutOffset(colormap);
791 mlib_d64 *plut = (mlib_d64*)mlib_ImageGetLutNormalTable(colormap) - lut_off;
792 mlib_s32 max_xsize = param -> max_xsize;
793 mlib_d64 buff[BUF_SIZE], *pbuff = buff;
794
795 if (max_xsize > BUF_SIZE) {
796 pbuff = mlib_malloc(max_xsize*sizeof(mlib_d64));
797
798 if (pbuff == NULL) return MLIB_FAILURE;
799 }
800
801 dX = (dX - (dX >> 31)) &~ 1; /* rounding towards ZERO */
802 dY = (dY - (dY >> 31)) &~ 1; /* rounding towards ZERO */
803 dx64 = vis_to_double_dup((((dX >> 1) & 0xFFFF) << 16) | ((dX >> 1) & 0xFFFF));
804 dy64 = vis_to_double_dup((((dY >> 1) & 0xFFFF) << 16) | ((dY >> 1) & 0xFFFF));
805
806 for (j = yStart; j <= yFinish; j++) {
807 DTYPE *sp;
808
809 NEW_LINE(1);
810
811 deltax = DOUBLE_4U16(X, X, X, X);
812 deltay = DOUBLE_4U16(Y, Y, Y, Y);
813
814 #pragma pipeloop(0)
815 for (i = 0; i < size; i++) {
816 sp = *(DTYPE**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT);
817 s0 = LUT(sp[0]);
818 s1 = LUT(sp[1]);
819 s2 = LUT(sp[srcYStride]);
820 s3 = LUT(sp[srcYStride + 1]);
821
822 BL_SUM();
823
824 pbuff[i] = dd;
825 X += dX;
826 Y += dY;
827 }
828
829 if (nchan == 3) {
830 mlib_ImageColorTrue2IndexLine_S16_U8_3_in_4((void*)pbuff, (void*)dl, size, colormap);
831 } else {
832 mlib_ImageColorTrue2IndexLine_S16_U8_4((void*)pbuff, (void*)dl, size, colormap);
833 }
834 }
835
836 if (pbuff != buff) {
837 mlib_free(pbuff);
838 }
839
840 return MLIB_SUCCESS;
841 }
842
843 /***************************************************************/
|
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26
27
28 /*
29 * The functions step along the lines from xLeft to xRight and apply
30 * the bilinear filtering.
31 *
32 */
33
34 #include "vis_proto.h"
35 #include "mlib_image.h"
36 #include "mlib_ImageCopy.h"
37 #include "mlib_ImageAffine.h"
38 #include "mlib_v_ImageFilters.h"
39 #include "mlib_v_ImageChannelExtract.h"
40
41 /*#define MLIB_VIS2*/
42
43 /***************************************************************/
44 #define DTYPE mlib_s16
45
46 #define FUN_NAME(CHAN) mlib_ImageAffine_s16_##CHAN##_bl
47
48 /***************************************************************/
49 static mlib_status FUN_NAME(2ch_na)(mlib_affine_param *param);
50 static mlib_status FUN_NAME(4ch_na)(mlib_affine_param *param);
51
52 /***************************************************************/
53 const mlib_u64 mlib_dmask_arr[] = {
54 0x0000000000000000, 0x000000000000FFFF, 0x00000000FFFF0000, 0x00000000FFFFFFFF,
55 0x0000FFFF00000000, 0x0000FFFF0000FFFF, 0x0000FFFFFFFF0000, 0x0000FFFFFFFFFFFF,
688 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 8*(X >> MLIB_SHIFT);
689
690 vis_alignaddr(sp, 0);
691 sp0 = AL_ADDR(sp, 0);
692 s0 = vis_faligndata(sp0[0], sp0[1]);
693 s1 = vis_faligndata(sp0[1], sp0[2]);
694
695 vis_alignaddr(sp, srcYStride);
696 sp1 = AL_ADDR(sp, srcYStride);
697 s2 = vis_faligndata(sp1[0], sp1[1]);
698 s3 = vis_faligndata(sp1[1], sp1[2]);
699
700 BL_SUM();
701
702 pbuff[i] = dd;
703 X += dX;
704 Y += dY;
705 }
706
707 mlib_ImageCopy_na((mlib_u8*)pbuff, dl, 8*size);
708 }
709
710 if (pbuff != buff) {
711 mlib_free(pbuff);
712 }
713
714 return MLIB_SUCCESS;
715 }
716
717 /***************************************************************/
|