Lines Matching refs:Allocation
27 * Every row in an RS allocation is guaranteed to be aligned by this amount, and
28 * every row in a user-backed allocation must be aligned by this amount.
47 class Allocation;
497 sp<const Element> ALLOCATION;
560 * from RenderScript kernels. An Allocation provides the backing store for a
563 * An Allocation also contains a set of usage flags that denote how the
564 * Allocation could be used. For example, an Allocation may have usage flags
567 * syncAll(int) in order to ensure that different users of the Allocation have
568 * a consistent view of memory. For example, in the case where an Allocation is
573 class Allocation : public BaseObj {
577 sp<Allocation> mAdaptedAllocation;
599 Allocation(void *id, sp<RS> rs, sp<const Type> t, uint32_t usage);
618 * Return Type for the allocation.
636 * Propagate changes from one usage of the Allocation to other usages of the Allocation.
642 * Send a buffer to the output stream. The contents of the Allocation will
644 * USAGE_IO_OUTPUT is set on the Allocation.
649 * Receive the latest input into the Allocation. This operation
650 * is only valid if USAGE_IO_INPUT is set on the Allocation.
658 * @return Surface associated with allocation
663 * Associate a Surface with this Allocation. This
665 * @param[in] s Surface to associate with allocation
671 * Generate a mipmap chain. This is only valid if the Type of the Allocation
674 * the Allocation is also using other memory spaces, a call to
675 * syncAll(Allocation.USAGE_SCRIPT) is required.
680 * Copy an array into part of this Allocation.
688 * Copy part of an Allocation into part of this Allocation.
691 * @param[in] data Allocation from which to copy
694 void copy1DRangeFrom(uint32_t off, size_t count, const sp<const Allocation>& data, uint32_t dataOff);
697 * Copy an array into part of this Allocation.
705 * Copy entire array to an Allocation.
711 * Copy entire Allocation to an array.
717 * Copy from an array into a rectangular region in this Allocation. The
719 * @param[in] xoff X offset of region to update in this Allocation
720 * @param[in] yoff Y offset of region to update in this Allocation
729 * Copy from this Allocation into a rectangular region in an array. The
731 * @param[in] xoff X offset of region to copy from this Allocation
732 * @param[in] yoff Y offset of region to copy from this Allocation
741 * Copy from an Allocation into a rectangular region in this Allocation.
742 * @param[in] xoff X offset of region to update in this Allocation
743 * @param[in] yoff Y offset of region to update in this Allocation
746 * @param[in] data Allocation from which to copy
751 const sp<const Allocation>& data, uint32_t dataXoff, uint32_t dataYoff);
754 * Copy from a strided array into a rectangular region in this Allocation.
755 * @param[in] xoff X offset of region to update in this Allocation
756 * @param[in] yoff Y offset of region to update in this Allocation
766 * Copy from a strided array into this Allocation.
773 * Copy from a rectangular region in this Allocation into a strided array.
774 * @param[in] xoff X offset of region to update in this Allocation
775 * @param[in] yoff Y offset of region to update in this Allocation
785 * Copy this Allocation into a strided array.
793 * Copy from an array into a 3D region in this Allocation. The
795 * @param[in] xoff X offset of region to update in this Allocation
796 * @param[in] yoff Y offset of region to update in this Allocation
797 * @param[in] zoff Z offset of region to update in this Allocation
807 * Copy from an Allocation into a 3D region in this Allocation.
808 * @param[in] xoff X offset of region to update in this Allocation
809 * @param[in] yoff Y offset of region to update in this Allocation
810 * @param[in] zoff Z offset of region to update in this Allocation
814 * @param[in] data Allocation from which to copy
821 const sp<const Allocation>& data,
825 * Copy a 3D region in this Allocation into an array. The
827 * @param[in] xoff X offset of region to update in this Allocation
828 * @param[in] yoff Y offset of region to update in this Allocation
829 * @param[in] zoff Z offset of region to update in this Allocation
839 * Creates an Allocation for use by scripts with a given Type.
840 * @param[in] rs Context to which the Allocation will belong
841 * @param[in] type Type of the Allocation
842 * @param[in] mipmaps desired mipmap behavior for the Allocation
843 * @param[in] usage usage for the Allocation
844 * @return new Allocation
846 static sp<Allocation> createTyped(const sp<RS>& rs, const sp<const Type>& type,
850 * Creates an Allocation for use by scripts with a given Type and a backing pointer. For use
852 * @param[in] rs Context to which the Allocation will belong
853 * @param[in] type Type of the Allocation
854 * @param[in] mipmaps desired mipmap behavior for the Allocation
855 * @param[in] usage usage for the Allocation
856 * @param[in] pointer existing backing store to use for this Allocation if possible
857 * @return new Allocation
859 static sp<Allocation> createTyped(const sp<RS>& rs, const sp<const Type>& type,
863 * Creates an Allocation for use by scripts with a given Type with no mipmaps.
864 * @param[in] rs Context to which the Allocation will belong
865 * @param[in] type Type of the Allocation
866 * @param[in] usage usage for the Allocation
867 * @return new Allocation
869 static sp<Allocation> createTyped(const sp<RS>& rs, const sp<const Type>& type,
872 * Creates an Allocation with a specified number of given elements.
873 * @param[in] rs Context to which the Allocation will belong
874 * @param[in] e Element used in the Allocation
875 * @param[in] count Number of elements of the Allocation
876 * @param[in] usage usage for the Allocation
877 * @return new Allocation
879 static sp<Allocation> createSized(const sp<RS>& rs, const sp<const Element>& e, size_t count,
883 * Creates a 2D Allocation with a specified number of given elements.
884 * @param[in] rs Context to which the Allocation will belong
885 * @param[in] e Element used in the Allocation
886 * @param[in] x Width in Elements of the Allocation
887 * @param[in] y Height of the Allocation
888 * @param[in] usage usage for the Allocation
889 * @return new Allocation
891 static sp<Allocation> createSized2D(const sp<RS>& rs, const sp<const Element>& e,
897 * Get the backing pointer for a USAGE_SHARED allocation.
899 * stride in bytes of a 2D Allocation
906 * An Element represents one item within an Allocation. An Element is roughly
918 * Sampler. Note that Allocation objects with DataKind USER cannot be used as
919 * input for a Sampler. In general, Allocation objects that are intended for
1087 * Utility function for returning an Element containing a single Allocation.
1091 static sp<const Element> ALLOCATION(const sp<RS> &rs);
1549 * A Type describes the Element and dimensions used for an Allocation or a
1562 * A Type also supports YUV format information to support an Allocation in a YUV
1567 friend class Allocation;
1587 * @return YUV format of the Allocation
1594 Allocation.
1595 * @return YUV format of the Allocation
1602 * Returns the X dimension of the Allocation.
1603 * @return X dimension of the allocation
1610 * Returns the Y dimension of the Allocation.
1611 * @return Y dimension of the allocation
1618 * Returns the Z dimension of the Allocation.
1619 * @return Z dimension of the allocation
1626 * Returns true if the Allocation has mipmaps.
1627 * @return true if the Allocation has mipmaps
1634 * Returns true if the Allocation is a cube map
1635 * @return true if the Allocation is a cube map
1642 * Returns number of accessible Elements in the Allocation
1643 * @return number of accessible Elements in the Allocation
1650 * Returns size in bytes of all Elements in the Allocation
1651 * @return size in bytes of all Elements in the Allocation
1701 void forEach(uint32_t slot, const sp<const Allocation>& in, const sp<const Allocation>& out,
1703 void bindAllocation(const sp<Allocation>& va, uint32_t slot) const;
1735 sp<Allocation> mAllocation;
1748 sp<const Allocation> getAllocation() {
1782 * allocation. The 8 nearest values are sampled and linearly interpolated. The
1799 * @param[in] ain input Allocation
1800 * @param[in] aout output Allocation
1802 void forEach(const sp<Allocation>& ain, const sp<Allocation>& aout);
1809 void setLUT(const sp<Allocation>& lut);
1842 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
1843 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
1846 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
1850 float alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1851 float beta, const sp<Allocation>& Y, int incY);
1861 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
1862 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
1865 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
1869 double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1870 double beta, const sp<Allocation>& Y, int incY);
1880 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
1881 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
1884 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
1888 Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1889 Float2 beta, const sp<Allocation>& Y, int incY);
1899 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
1900 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
1903 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
1907 Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1908 Double2 beta, const sp<Allocation>& Y, int incY);
1916 * Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
1927 * @param A The input allocation contains the band matrix A, supported elements type: {Element#F32}.
1928 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
1931 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
1935 int KL, int KU, float alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
1936 float beta, const sp<Allocation>& Y, int incY);
1944 * Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
1955 * @param A The input allocation contains the band matrix A, supported elements type: {Element#F64}.
1956 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
1959 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
1963 int KL, int KU, double alpha, const sp<Allocation>& A, const sp<Allocation>& X,
1964 int incX, double beta, const sp<Allocation>& Y, int incY);
1972 * Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
1983 * @param A The input allocation contains the band matrix A, supported elements type: {Element#F32_2}.
1984 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
1987 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
1991 int KL, int KU, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
1992 int incX, Float2 beta, const sp<Allocation>& Y, int incY);
2000 * Note: For a M*N matrix, the input Allocation should also be of size M*N (dimY = M, dimX = N),
2011 * @param A The input allocation contains the band matrix A, supported elements type: {Element#F64_2}.
2012 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2015 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
2019 int KL, int KU, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
2020 Double2 beta, const sp<Allocation>& Y, int incY);
2031 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2032 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2036 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2047 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2048 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2052 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2063 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2064 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2068 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2079 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
2080 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2084 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2092 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2103 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2104 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2108 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2116 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2127 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2128 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2132 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2140 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2151 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2152 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2156 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2164 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2175 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
2176 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2180 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2188 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2199 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32}.
2200 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2204 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2212 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2223 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64}.
2224 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2228 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2236 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2247 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32_2}.
2248 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2252 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2260 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2271 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64_2}.
2272 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2276 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2287 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2288 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2292 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2303 allocation contains matrix A, supported elements type: {Element#F64}.
2304 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2308 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2319 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2320 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2324 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2335 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
2336 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2340 const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2348 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2359 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2360 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2364 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2372 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2383 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2384 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2388 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2396 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2407 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2408 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2412 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2420 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2431 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
2432 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2436 int K, const sp<Allocation>& A, const sp<Allocation>& X, int incX);
2444 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2455 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32}.
2456 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2460 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2468 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2479 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64}.
2480 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2484 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2492 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2503 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F32_2}.
2504 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2508 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2516 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2527 * @param Ap The input allocation contains packed matrix A, supported elements type: {Element#F64_2}.
2528 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
2532 const sp<Allocation>& Ap, const sp<Allocation>& X, int incX);
2542 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2543 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2546 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
2549 void SSYMV(RsBlasUplo Uplo, float alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2550 int incX, float beta, const sp<Allocation>& Y, int incY);
2558 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2568 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2569 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2572 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
2575 void SSBMV(RsBlasUplo Uplo, int K, float alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2576 int incX, float beta, const sp<Allocation>& Y, int incY);
2584 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2594 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F32}.
2595 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2598 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
2601 void SSPMV(RsBlasUplo Uplo, float alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
2602 int incX, float beta, const sp<Allocation>& Y, int incY);
2611 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2613 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
2615 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2617 void SGER(float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
2627 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2629 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2631 void SSYR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
2639 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2649 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2651 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F32}.
2653 void SSPR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
2663 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2665 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
2667 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
2669 void SSYR2(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX,
2670 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
2678 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2688 * @param X The input allocation contains vector x, supported elements type: {Element#F32}.
2690 * @param Y The input allocation contains vector y, supported elements type: {Element#F32}.
2692 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F32}.
2694 void SSPR2(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX,
2695 const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
2705 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2706 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2709 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
2712 void DSYMV(RsBlasUplo Uplo, double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
2713 double beta, const sp<Allocation>& Y, int incY);
2721 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2731 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2732 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2735 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
2738 void DSBMV(RsBlasUplo Uplo, int K, double alpha, const sp<Allocation>& A, const sp<Allocation>& X, int incX,
2739 double beta, const sp<Allocation>& Y, int incY);
2747 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2757 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F64}.
2758 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2761 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
2764 void DSPMV(RsBlasUplo Uplo, double alpha, const sp<Allocation>& Ap, const sp<Allocation>& X, int incX,
2765 double beta, const sp<Allocation>& Y, int incY);
2774 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2776 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
2778 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2780 void DGER(double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
2790 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2792 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2794 void DSYR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
2802 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2812 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2814 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F64}.
2816 void DSPR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
2826 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2828 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
2830 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
2832 void DSYR2(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX,
2833 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
2841 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2851 * @param X The input allocation contains vector x, supported elements type: {Element#F64}.
2853 * @param Y The input allocation contains vector y, supported elements type: {Element#F64}.
2855 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F64}.
2857 void DSPR2(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX,
2858 const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
2868 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2869 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2872 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
2875 void CHEMV(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2876 int incX, Float2 beta, const sp<Allocation>& Y, int incY);
2884 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
2894 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2895 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2898 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
2901 void CHBMV(RsBlasUplo Uplo, int K, Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
2902 int incX, Float2 beta, const sp<Allocation>& Y, int incY);
2910 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2920 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2921 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2924 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
2927 void CHPMV(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
2928 int incX, Float2 beta, const sp<Allocation>& Y, int incY);
2937 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2939 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
2941 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2943 void CGERU(Float2 alpha, const sp<Allocation>& X, int incX,
2944 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
2953 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2955 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
2957 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2959 void CGERC(Float2 alpha, const sp<Allocation>& X, int incX,
2960 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
2970 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2972 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2974 void CHER(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
2982 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
2992 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
2994 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F32_2}.
2996 void CHPR(RsBlasUplo Uplo, float alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
3006 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
3008 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
3010 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3012 void CHER2(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& X, int incX,
3013 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
3021 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
3031 * @param X The input allocation contains vector x, supported elements type: {Element#F32_2}.
3033 * @param Y The input allocation contains vector y, supported elements type: {Element#F32_2}.
3035 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3037 void CHPR2(RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& X, int incX,
3038 const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
3048 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3049 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3052 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3055 void ZHEMV(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
3056 int incX, Double2 beta, const sp<Allocation>& Y, int incY);
3064 * Note: For a N*N matrix, the input Allocation should also be of size N*N (dimY = N, dimX = N),
3074 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3075 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3078 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3081 void ZHBMV(RsBlasUplo Uplo, int K, Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& X,
3082 int incX, Double2 beta, const sp<Allocation>& Y, int incY);
3090 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
3100 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3101 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3104 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3107 void ZHPMV(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& Ap, const sp<Allocation>& X,
3108 int incX, Double2 beta, const sp<Allocation>& Y, int incY);
3117 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3119 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3121 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3123 void ZGERU(Double2 alpha, const sp<Allocation>& X, int incX,
3124 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
3133 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3135 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3137 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3139 void ZGERC(Double2 alpha, const sp<Allocation>& X, int incX,
3140 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
3150 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3152 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3154 void ZHER(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& A);
3162 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
3172 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3174 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3176 void ZHPR(RsBlasUplo Uplo, double alpha, const sp<Allocation>& X, int incX, const sp<Allocation>& Ap);
3186 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3188 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3190 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3192 void ZHER2(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& X, int incX,
3193 const sp<Allocation>& Y, int incY, const sp<Allocation>& A);
3201 * Note: For a N*N matrix, the input Allocation should be a 1D allocation of size dimX = N*(N+1)/2,
3211 * @param X The input allocation contains vector x, supported elements type: {Element#F64_2}.
3213 * @param Y The input allocation contains vector y, supported elements type: {Element#F64_2}.
3215 * @param Ap The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3217 void ZHPR2(RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& X, int incX,
3218 const sp<Allocation>& Y, int incY, const sp<Allocation>& Ap);
3229 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
3230 * @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
3232 * @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
3234 void SGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, float alpha, const sp<Allocation>& A,
3235 const sp<Allocation>& B, float beta, const sp<Allocation>& C);
3247 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
3248 * @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
3250 * @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
3252 void DGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, double alpha, const sp<Allocation>& A,
3253 const sp<Allocation>& B, double beta, const sp<Allocation>& C);
3264 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3265 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3267 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3269 void CGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, Float2 alpha, const sp<Allocation>& A,
3270 const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
3281 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3282 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3284 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3286 void ZGEMM(RsBlasTranspose TransA, RsBlasTranspose TransB, Double2 alpha, const sp<Allocation>& A,
3287 const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
3298 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
3299 * @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
3301 * @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
3303 void SSYMM(RsBlasSide Side, RsBlasUplo Uplo, float alpha, const sp<Allocation>& A,
3304 const sp<Allocation>& B, float beta, const sp<Allocation>& C);
3315 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
3316 * @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
3318 * @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
3320 void DSYMM(RsBlasSide Side, RsBlasUplo Uplo, double alpha, const sp<Allocation>& A,
3321 const sp<Allocation>& B, double beta, const sp<Allocation>& C);
3332 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3333 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3335 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3337 void CSYMM(RsBlasSide Side, RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A,
3338 const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
3349 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3350 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3352 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3354 void ZSYMM(RsBlasSide Side, RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A,
3355 const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
3366 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
3368 * @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
3371 const sp<Allocation>& A, float beta, const sp<Allocation>& C);
3382 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
3384 * @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
3387 const sp<Allocation>& A, double beta, const sp<Allocation>& C);
3398 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3400 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3403 const sp<Allocation>& A, Float2 beta, const sp<Allocation>& C);
3414 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3416 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3419 const sp<Allocation>& A, Double2 beta, const sp<Allocation>& C);
3430 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
3431 * @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
3433 * @param C The input allocation contains matrix C, supported elements type: {Element#F32}.
3436 const sp<Allocation>& A, const sp<Allocation>& B, float beta, const sp<Allocation>& C);
3447 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
3448 * @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
3450 * @param C The input allocation contains matrix C, supported elements type: {Element#F64}.
3453 const sp<Allocation>& A, const sp<Allocation>& B, double beta, const sp<Allocation>& C);
3464 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3465 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3467 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3470 const sp<Allocation>& A, const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
3481 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3482 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3484 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3487 const sp<Allocation>& A, const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
3501 * @param A The input allocation
3502 * @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
3505 RsBlasDiag Diag, float alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3519 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
3520 * @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
3523 double alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3537 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3538 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3541 Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3555 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3556 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3559 Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3573 * @param A The input allocation contains matrix A, supported elements type: {Element#F32}.
3574 * @param B The input allocation contains matrix B, supported elements type: {Element#F32}.
3577 float alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3591 * @param A The input allocation contains matrix A, supported elements type: {Element#F64}.
3592 * @param B The input allocation contains matrix B, supported elements type: {Element#F64}.
3595 double alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3609 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3610 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3613 Float2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3627 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3628 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3631 Double2 alpha, const sp<Allocation>& A, const sp<Allocation>& B);
3642 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3643 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3645 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3647 void CHEMM(RsBlasSide Side, RsBlasUplo Uplo, Float2 alpha, const sp<Allocation>& A,
3648 const sp<Allocation>& B, Float2 beta, const sp<Allocation>& C);
3659 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3660 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3662 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3664 void ZHEMM(RsBlasSide Side, RsBlasUplo Uplo, Double2 alpha, const sp<Allocation>& A,
3665 const sp<Allocation>& B, Double2 beta, const sp<Allocation>& C);
3676 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3678 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3680 void CHERK(RsBlasUplo Uplo, RsBlasTranspose Trans, float alpha, const sp<Allocation>& A,
3681 float beta, const sp<Allocation>& C);
3692 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3694 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3696 void ZHERK(RsBlasUplo Uplo, RsBlasTranspose Trans, double alpha, const sp<Allocation>& A,
3697 double beta, const sp<Allocation>& C);
3708 * @param A The input allocation contains matrix A, supported elements type: {Element#F32_2}.
3709 * @param B The input allocation contains matrix B, supported elements type: {Element#F32_2}.
3711 * @param C The input allocation contains matrix C, supported elements type: {Element#F32_2}.
3713 void CHER2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Float2 alpha, const sp<Allocation>& A,
3714 const sp<Allocation>& B, float beta, const sp<Allocation>& C);
3725 * @param A The input allocation contains matrix A, supported elements type: {Element#F64_2}.
3726 * @param B The input allocation contains matrix B, supported elements type: {Element#F64_2}.
3728 * @param C The input allocation contains matrix C, supported elements type: {Element#F64_2}.
3730 void ZHER2K(RsBlasUplo Uplo, RsBlasTranspose Trans, Double2 alpha, const sp<Allocation>& A,
3731 const sp<Allocation>& B, double beta, const sp<Allocation>& C);
3740 * @param A The input allocation contains matrix A, supported elements type: {Element#U8}.
3742 * @param B The input allocation contains matrix B, supported elements type: {Element#U8}.
3744 * @param C The input allocation contains matrix C, supported elements type: {Element#U8}.
3748 void BNNM(const sp<Allocation>& A, int a_offset, const sp<Allocation>& B, int b_offset, const sp<Allocation>& C,
3768 * @param[in] in input Allocation
3769 * @param[in] out output Allocation
3771 void forEachClear(const sp<Allocation>& in, const sp<Allocation>& out);
3774 * @param[in] in input Allocation
3775 * @param[in] out output Allocation
3777 void forEachSrc(const sp<Allocation>& in, const sp<Allocation>& out);
3780 * @param[in] in input Allocation
3781 * @param[in] out output Allocation
3783 void forEachDst(const sp<Allocation>& in, const sp<Allocation>& out);
3786 * @param[in] in input Allocation
3787 * @param[in] out output Allocation
3789 void forEachSrcOver(const sp<Allocation>& in, const sp<Allocation>& out);
3792 * @param[in] in input Allocation
3793 * @param[in] out output Allocation
3795 void forEachDstOver(const sp<Allocation>& in, const sp<Allocation>& out);
3798 * @param[in] in input Allocation
3799 * @param[in] out output Allocation
3801 void forEachSrcIn(const sp<Allocation>& in, const sp<Allocation>& out);
3804 * @param[in] in input Allocation
3805 * @param[in] out output Allocation
3807 void forEachDstIn(const sp<Allocation>& in, const sp<Allocation>& out);
3810 * @param[in] in input Allocation
3811 * @param[in] out output Allocation
3813 void forEachSrcOut(const sp<Allocation>& in, const sp<Allocation>& out);
3816 * @param[in] in input Allocation
3817 * @param[in] out output Allocation
3819 void forEachDstOut(const sp<Allocation>& in, const sp<Allocation>& out);
3822 * @param[in] in input Allocation
3823 * @param[in] out output Allocation
3825 void forEachSrcAtop(const sp<Allocation>& in, const sp<Allocation>& out);
3828 * @param[in] in input Allocation
3829 * @param[in] out output Allocation
3831 void forEachDstAtop(const sp<Allocation>& in, const sp<Allocation>& out);
3834 * @param[in] in input Allocation
3835 * @param[in] out output Allocation
3837 void forEachXor(const sp<Allocation>& in, const sp<Allocation>& out);
3840 * @param[in] in input Allocation
3841 * @param[in] out output Allocation
3843 void forEachMultiply(const sp<Allocation>& in, const sp<Allocation>& out);
3846 * @param[in] in input Allocation
3847 * @param[in] out output Allocation
3849 void forEachAdd(const sp<Allocation>& in, const sp<Allocation>& out);
3852 * @param[in] in input Allocation
3853 * @param[in] out output Allocation
3855 void forEachSubtract(const sp<Allocation>& in, const sp<Allocation>& out);
3860 * radius to all elements of an Allocation.
3875 * @param[in] in input Allocation
3877 void setInput(const sp<Allocation>& in);
3880 * @param[in] output Allocation
3882 void forEach(const sp<Allocation>& out);
3910 * @param[in] in input Allocation
3911 * @param[out] out output Allocation
3913 void forEach(const sp<Allocation>& in, const sp<Allocation>& out);
3953 * Intrinsic for applying a 3x3 convolve to an allocation.
3969 * @param[in] in input Allocation
3971 void setInput(const sp<Allocation>& in);
3974 * @param[in] out output Allocation
3976 void forEach(const sp<Allocation>& out);
3985 * Intrinsic for applying a 5x5 convolve to an allocation.
4001 * @param[in] in input Allocation
4003 void setInput(const sp<Allocation>& in);
4006 * @param[in] out output Allocation
4008 void forEach(const sp<Allocation>& out);
4022 sp<Allocation> mOut;
4040 * @param[in] aout The output allocation
4042 void setOutput(const sp<Allocation>& aout);
4057 * allocation. The output allocation may be a narrower vector size
4067 void forEach(const sp<Allocation>& ain);
4070 * allocation. The dot product of the input channel and the
4078 void forEach_dot(const sp<Allocation>& ain);
4088 sp<Allocation> LUT;
4110 * @param[in] ain Input allocation
4111 * @param[in] aout Output allocation
4113 void forEach(const sp<Allocation>& ain, const sp<Allocation>& aout);
4146 * Intrinsic for performing a resize of a 2D allocation.
4150 sp<Allocation> mInput;
4162 * Resize copy the input allocation to the output specified. The
4163 * Allocation is rescaled if necessary using bi-cubic
4165 * @param[in] ain input Allocation
4166 * @param[in] aout output Allocation
4168 void forEach_bicubic(const sp<Allocation>& aout);
4174 void setInput(const sp<Allocation>& ain);
4180 * The input allocation should be supplied in a supported YUV format
4181 * as a YUV element Allocation. The output is RGBA; the alpha channel
4200 * Set the input YUV allocation.
4202 * @param[in] ain The input allocation.
4204 void setInput(const sp<Allocation>& in);
4209 * @param[in] aout Output allocation. Must match creation element
4212 void forEach(const sp<Allocation>& out);
4221 * Any Allocation used with a Sampler must have been created with
4223 * Allocation that was not created with
