summaryrefslogtreecommitdiffstats
path: root/media/libdrm/mobile2/src/util/ustl-1.0/utuple.h
diff options
context:
space:
mode:
Diffstat (limited to 'media/libdrm/mobile2/src/util/ustl-1.0/utuple.h')
-rw-r--r--media/libdrm/mobile2/src/util/ustl-1.0/utuple.h247
1 files changed, 0 insertions, 247 deletions
diff --git a/media/libdrm/mobile2/src/util/ustl-1.0/utuple.h b/media/libdrm/mobile2/src/util/ustl-1.0/utuple.h
deleted file mode 100644
index 8a003ab..0000000
--- a/media/libdrm/mobile2/src/util/ustl-1.0/utuple.h
+++ /dev/null
@@ -1,247 +0,0 @@
-// This file is part of the ustl library, an STL implementation.
-//
-// Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net>
-// This file is free software, distributed under the MIT License.
-//
-// utuple.h
-//
-
-#ifndef UTUPLE_H_7324ADEC49B397CA74A56F6050FD5A6B
-#define UTUPLE_H_7324ADEC49B397CA74A56F6050FD5A6B
-
-#include "ualgo.h"
-
-#if PLATFORM_ANDROID
-#undef CPU_HAS_MMX
-#endif
-
-namespace ustl {
-
-/// \class tuple utuple.h ustl.h
-/// \ingroup Sequences
-///
-/// \brief A fixed-size array of \p N \p Ts.
-///
-template <size_t N, typename T>
-class tuple {
-public:
- typedef T value_type;
- typedef size_t size_type;
- typedef value_type* pointer;
- typedef const value_type* const_pointer;
- typedef value_type& reference;
- typedef const value_type& const_reference;
- typedef pointer iterator;
- typedef const_pointer const_iterator;
- typedef ::ustl::reverse_iterator<iterator> reverse_iterator;
- typedef ::ustl::reverse_iterator<const_iterator> const_reverse_iterator;
- typedef pair<iterator,iterator> range_t;
- typedef pair<const_iterator,const_iterator> const_range_t;
-public:
- template <typename T2>
- inline tuple (const tuple<N,T2>& t);
- inline tuple (const tuple<N,T>& t);
- inline tuple (const_pointer v);
- inline tuple (void) { for (uoff_t i = 0; i < N; ++ i) m_v[i] = T(); }
- explicit inline tuple (const_reference v0, const_reference v1 = T(), const_reference v2 = T(), const_reference v3 = T());
- inline iterator begin (void) { return (m_v); }
- inline const_iterator begin (void) const { return (m_v); }
- inline iterator end (void) { return (begin() + N); }
- inline const_iterator end (void) const { return (begin() + N); }
- inline size_type size (void) const { return (N); }
- inline size_type max_size (void) const { return (N); }
- inline bool empty (void) const { return (N == 0); }
- inline const_reference at (size_type i) const { return (m_v[i]); }
- inline reference at (size_type i) { return (m_v[i]); }
- inline const_reference operator[] (size_type i) const { return (m_v[i]); }
- inline reference operator[] (size_type i) { return (m_v[i]); }
- template <typename T2>
- inline const tuple& operator= (const tuple<N,T2>& src);
- inline const tuple& operator= (const tuple<N,T>& src);
- inline const tuple& operator+= (const_reference v)
- { for (uoff_t i = 0; i < N; ++ i) m_v[i] += v; return (*this); }
- inline const tuple& operator-= (const_reference v)
- { for (uoff_t i = 0; i < N; ++ i) m_v[i] -= v; return (*this); }
- inline const tuple& operator*= (const_reference v)
- { for (uoff_t i = 0; i < N; ++ i) m_v[i] *= v; return (*this); }
- inline const tuple& operator/= (const_reference v)
- { for (uoff_t i = 0; i < N; ++ i) m_v[i] /= v; return (*this); }
- inline const tuple operator+ (const_reference v) const
- { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] + v; return (result); }
- inline const tuple operator- (const_reference v) const
- { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] - v; return (result); }
- inline const tuple operator* (const_reference v) const
- { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] * v; return (result); }
- inline const tuple operator/ (const_reference v) const
- { tuple result; for (uoff_t i = 0; i < N; ++ i) result[i] = m_v[i] / v; return (result); }
- inline void swap (tuple<N,T>& v)
- { for (uoff_t i = 0; i < N; ++ i) ::ustl::swap (m_v[i], v.m_v[i]); }
-private:
- T m_v [N];
-};
-
-} // namespace ustl
-
-#include "simd.h"
-
-namespace ustl {
-
-template <size_t N, typename T>
-template <typename T2>
-inline tuple<N,T>::tuple (const tuple<N,T2>& t)
-{ simd::pconvert (t, *this, simd::fcast<T2,T>()); }
-
-template <size_t N, typename T>
-inline tuple<N,T>::tuple (const tuple<N,T>& t)
-{ simd::passign (t, *this); }
-
-template <size_t N, typename T>
-inline tuple<N,T>::tuple (const_pointer v)
-{ simd::ipassign (v, *this); }
-
-template <size_t N, typename T>
-inline tuple<N,T>::tuple (const_reference v0, const_reference v1, const_reference v2, const_reference v3)
-{
- m_v[0] = v0;
- if (N > 1) m_v[1] = v1;
- if (N > 2) m_v[2] = v2;
- if (N > 3) m_v[3] = v3;
- if (N > 4) fill_n (m_v + 4, N - 4, T());
-}
-
-template <size_t N, typename T>
-template <typename T2>
-inline const tuple<N,T>& tuple<N,T>::operator= (const tuple<N,T2>& src)
-{ simd::pconvert (src, *this, simd::fcast<T2,T>()); return (*this); }
-
-template <size_t N, typename T>
-inline const tuple<N,T>& tuple<N,T>::operator= (const tuple<N,T>& src)
-{ simd::passign (src, *this); return (*this); }
-
-template <size_t N, typename T1, typename T2>
-inline bool operator== (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
-{
- for (uoff_t i = 0; i < N; ++ i)
- if (t1[i] != t2[i])
- return (false);
- return (true);
-}
-
-template <size_t N, typename T1, typename T2>
-inline bool operator< (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
-{
- for (uoff_t i = 0; i < N && t1[i] <= t2[i]; ++ i)
- if (t1[i] < t2[i])
- return (true);
- return (false);
-}
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1>& operator+= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
- { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] + t2[i]); return (t1); }
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1>& operator-= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
- { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] - t2[i]); return (t1); }
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1>& operator*= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
- { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] * t2[i]); return (t1); }
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1>& operator/= (tuple<N,T1>& t1, const tuple<N,T2>& t2)
- { for (uoff_t i = 0; i < N; ++ i) t1[i] = T1(t1[i] / t2[i]); return (t1); }
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1> operator+ (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
-{
- tuple<N,T1> result;
- for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] + t2[i]);
- return (result);
-}
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1> operator- (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
-{
- tuple<N,T1> result;
- for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] - t2[i]);
- return (result);
-}
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1> operator* (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
-{
- tuple<N,T1> result;
- for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] * t2[i]);
- return (result);
-}
-
-template <size_t N, typename T1, typename T2>
-inline const tuple<N,T1> operator/ (const tuple<N,T1>& t1, const tuple<N,T2>& t2)
-{
- tuple<N,T1> result;
- for (uoff_t i = 0; i < N; ++ i) result[i] = T1(t1[i] / t2[i]);
- return (result);
-}
-
-#if CPU_HAS_SSE
-#define SSE_TUPLE_SPECS(n,type) \
-template <> inline tuple<n,type>::tuple (void) \
-{ asm ("xorps %%xmm0, %%xmm0\n\tmovups %%xmm0, %0"::"m"(m_v[0]):"xmm0","memory"); } \
-template<> inline void tuple<n,type>::swap (tuple<n,type>& v) \
-{ asm ("movups %0,%%xmm0\n\tmovups %1,%%xmm1\n\tmovups %%xmm0,%1\n\tmovups %%xmm1,%0"::"m"(m_v[0]),"m"(v.m_v[0]):"xmm0","xmm1","memory"); }
-SSE_TUPLE_SPECS(4,float)
-SSE_TUPLE_SPECS(4,int32_t)
-SSE_TUPLE_SPECS(4,uint32_t)
-#undef SSE_TUPLE_SPECS
-#endif
-#if CPU_HAS_MMX
-#define MMX_TUPLE_SPECS(n,type) \
-template <> inline tuple<n,type>::tuple (void) \
-{ asm ("pxor %%mm0, %%mm0\n\tmovq %%mm0, %0"::"m"(m_v[0]):"mm0","memory"); simd::reset_mmx(); } \
-template<> inline void tuple<n,type>::swap (tuple<n,type>& v) \
-{ asm ("movq %0,%%mm0\n\tmovq %1,%%mm1\n\tmovq %%mm0,%1\n\tmovq %%mm1,%0"::"m"(m_v[0]),"m"(v.m_v[0]):"mm0","mm1","memory"); simd::reset_mmx(); }
-MMX_TUPLE_SPECS(2,float)
-MMX_TUPLE_SPECS(4,int16_t)
-MMX_TUPLE_SPECS(4,uint16_t)
-MMX_TUPLE_SPECS(2,int32_t)
-MMX_TUPLE_SPECS(2,uint32_t)
-MMX_TUPLE_SPECS(8,int8_t)
-MMX_TUPLE_SPECS(8,uint8_t)
-#undef MMX_TUPLE_SPECS
-#endif
-
-#define SIMD_TUPLE_PACKOP(N,T) \
-template <> inline const tuple<N,T>& operator+= (tuple<N,T>& t1, const tuple<N,T>& t2) \
- { simd::padd (t2, t1); return (t1); } \
-template <> inline const tuple<N,T>& operator-= (tuple<N,T>& t1, const tuple<N,T>& t2) \
- { simd::psub (t2, t1); return (t1); } \
-template <> inline const tuple<N,T>& operator*= (tuple<N,T>& t1, const tuple<N,T>& t2) \
- { simd::pmul (t2, t1); return (t1); } \
-template <> inline const tuple<N,T>& operator/= (tuple<N,T>& t1, const tuple<N,T>& t2) \
- { simd::pdiv (t2, t1); return (t1); } \
-template <> inline const tuple<N,T> operator+ (const tuple<N,T>& t1, const tuple<N,T>& t2) \
- { tuple<N,T> result (t1); simd::padd (t2, result); return (result); } \
-template <> inline const tuple<N,T> operator- (const tuple<N,T>& t1, const tuple<N,T>& t2) \
- { tuple<N,T> result (t1); simd::psub (t2, result); return (result); } \
-template <> inline const tuple<N,T> operator* (const tuple<N,T>& t1, const tuple<N,T>& t2) \
- { tuple<N,T> result (t1); simd::pmul (t2, result); return (result); } \
-template <> inline const tuple<N,T> operator/ (const tuple<N,T>& t1, const tuple<N,T>& t2) \
- { tuple<N,T> result (t1); simd::pdiv (t2, result); return (result); }
-SIMD_TUPLE_PACKOP(4,float)
-SIMD_TUPLE_PACKOP(2,float)
-SIMD_TUPLE_PACKOP(2,double)
-SIMD_TUPLE_PACKOP(4,int32_t)
-SIMD_TUPLE_PACKOP(4,uint32_t)
-SIMD_TUPLE_PACKOP(4,int16_t)
-SIMD_TUPLE_PACKOP(4,uint16_t)
-SIMD_TUPLE_PACKOP(2,int32_t)
-SIMD_TUPLE_PACKOP(2,uint32_t)
-SIMD_TUPLE_PACKOP(8,int8_t)
-SIMD_TUPLE_PACKOP(8,uint8_t)
-#undef SIMD_TUPLE_PACKOP
-
-} // namespace ustl
-
-#endif
-
generated by cgit v1.1 at 2025-01-10 20:54:23 +0000