remove deprecated v1 style function j2k_read_cod

[openjpeg.git] / libopenjpeg / mct.c

diff --git a/libopenjpeg/mct.c b/libopenjpeg/mct.c
index ca21744f3e48ec6d1c50e05edfc61aa6d271be95..ed34be9c6bdaa2ef0d38e539aed32f4a29125355 100644 (file)
--- a/libopenjpeg/mct.c
+++ b/libopenjpeg/mct.c
@@ -29,6 +29,10 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+
 #include "opj_includes.h"
 
 /* <summary> */
@@ -41,6 +45,16 @@ static const double mct_norms[3] = { 1.732, .8292, .8292 };
 /* </summary> */
 static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
 
+const OPJ_FLOAT64 * get_mct_norms ()
+{
+       return mct_norms;
+}
+
+const OPJ_FLOAT64 * get_mct_norms_real ()
+{
+       return mct_norms_real;
+}
+
 /* <summary> */
 /* Foward reversible MCT. */
 /* </summary> */
@@ -127,6 +141,44 @@ void mct_decode_real(
                int n)
 {
        int i;
+#ifdef __SSE__
+       __m128 vrv, vgu, vgv, vbu;
+       vrv = _mm_set1_ps(1.402f);
+       vgu = _mm_set1_ps(0.34413f);
+       vgv = _mm_set1_ps(0.71414f);
+       vbu = _mm_set1_ps(1.772f);
+       for (i = 0; i < (n >> 3); ++i) {
+               __m128 vy, vu, vv;
+               __m128 vr, vg, vb;
+
+               vy = _mm_load_ps(c0);
+               vu = _mm_load_ps(c1);
+               vv = _mm_load_ps(c2);
+               vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
+               vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
+               vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
+               _mm_store_ps(c0, vr);
+               _mm_store_ps(c1, vg);
+               _mm_store_ps(c2, vb);
+               c0 += 4;
+               c1 += 4;
+               c2 += 4;
+
+               vy = _mm_load_ps(c0);
+               vu = _mm_load_ps(c1);
+               vv = _mm_load_ps(c2);
+               vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
+               vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
+               vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
+               _mm_store_ps(c0, vr);
+               _mm_store_ps(c1, vg);
+               _mm_store_ps(c2, vb);
+               c0 += 4;
+               c1 += 4;
+               c2 += 4;
+       }
+       n &= 7;
+#endif
        for(i = 0; i < n; ++i) {
                float y = c0[i];
                float u = c1[i];
@@ -146,3 +198,136 @@ void mct_decode_real(
 double mct_getnorm_real(int compno) {
        return mct_norms_real[compno];
 }
+
+
+opj_bool mct_encode_custom(
+                                          // MCT data
+                                          OPJ_BYTE * pCodingdata,
+                                          // size of components
+                                          OPJ_UINT32 n,
+                                          // components
+                                          OPJ_BYTE ** pData,
+                                          // nb of components (i.e. size of pData)
+                                          OPJ_UINT32 pNbComp,
+                                          // tells if the data is signed
+                                          OPJ_UINT32 isSigned)
+{
+       OPJ_FLOAT32 * lMct = (OPJ_FLOAT32 *) pCodingdata;
+       OPJ_UINT32 i;
+       OPJ_UINT32 j;
+       OPJ_UINT32 k;
+       OPJ_UINT32 lNbMatCoeff = pNbComp * pNbComp;
+       OPJ_INT32 * lCurrentData = 00;
+       OPJ_INT32 * lCurrentMatrix = 00;
+       OPJ_INT32 ** lData = (OPJ_INT32 **) pData;
+       OPJ_UINT32 lMultiplicator = 1 << 13;
+       OPJ_INT32 * lMctPtr;
+
+       lCurrentData = (OPJ_INT32 *) opj_malloc((pNbComp + lNbMatCoeff) * sizeof(OPJ_INT32));
+       if (! lCurrentData) {
+               return OPJ_FALSE;
+       }
+
+       lCurrentMatrix = lCurrentData + pNbComp;
+
+       for (i =0;i<lNbMatCoeff;++i) {
+               lCurrentMatrix[i] = (OPJ_INT32) (*(lMct++) * lMultiplicator);
+       }
+
+       for (i = 0; i < n; ++i)  {
+               lMctPtr = lCurrentMatrix;
+               for (j=0;j<pNbComp;++j) {
+                       lCurrentData[j] = (*(lData[j]));
+               }
+
+               for (j=0;j<pNbComp;++j) {
+                       *(lData[j]) = 0;
+                       for (k=0;k<pNbComp;++k) {
+                               *(lData[j]) += fix_mul(*lMctPtr, lCurrentData[k]);
+                               ++lMctPtr;
+                       }
+
+                       ++lData[j];
+               }
+       }
+
+       opj_free(lCurrentData);
+
+       return OPJ_TRUE;
+}
+
+opj_bool mct_decode_custom(
+                                          /* MCT data */
+                                          OPJ_BYTE * pDecodingData,
+                                          /* size of components */
+                                          OPJ_UINT32 n,
+                                          /* components */
+                                          OPJ_BYTE ** pData,
+                                          /* nb of components (i.e. size of pData) */
+                                          OPJ_UINT32 pNbComp,
+                                          /* tells if the data is signed */
+                                          OPJ_UINT32 isSigned)
+{
+       OPJ_FLOAT32 * lMct;
+       OPJ_UINT32 i;
+       OPJ_UINT32 j;
+       OPJ_UINT32 k;
+
+       OPJ_FLOAT32 * lCurrentData = 00;
+       OPJ_FLOAT32 * lCurrentResult = 00;
+       OPJ_FLOAT32 ** lData = (OPJ_FLOAT32 **) pData;
+
+       lCurrentData = (OPJ_FLOAT32 *) opj_malloc (2 * pNbComp * sizeof(OPJ_FLOAT32));
+       if
+               (! lCurrentData)
+       {
+               return OPJ_FALSE;
+       }
+       lCurrentResult = lCurrentData + pNbComp;
+
+       for
+               (i = 0; i < n; ++i)
+       {
+               lMct = (OPJ_FLOAT32 *) pDecodingData;
+               for
+                       (j=0;j<pNbComp;++j)
+               {
+                       lCurrentData[j] = (OPJ_FLOAT32) (*(lData[j]));
+               }
+               for
+                       (j=0;j<pNbComp;++j)
+               {
+                       lCurrentResult[j] = 0;
+                       for
+                               (k=0;k<pNbComp;++k)
+                       {
+                               lCurrentResult[j] += *(lMct++) * lCurrentData[k];
+                       }
+                       *(lData[j]++) = (OPJ_FLOAT32) (lCurrentResult[j]);
+               }
+       }
+       opj_free(lCurrentData);
+       return OPJ_TRUE;
+}
+
+void opj_calculate_norms(      OPJ_FLOAT64 * pNorms,
+                                                       OPJ_UINT32 pNbComps,
+                                                       OPJ_FLOAT32 * pMatrix)
+{
+       OPJ_UINT32 i,j,lIndex;
+       OPJ_FLOAT32 lCurrentValue;
+       OPJ_FLOAT64 * lNorms = (OPJ_FLOAT64 *) pNorms;
+       OPJ_FLOAT32 * lMatrix = (OPJ_FLOAT32 *) pMatrix;
+
+       for     (i=0;i<pNbComps;++i) {
+               lNorms[i] = 0;
+               lIndex = i;
+
+               for     (j=0;j<pNbComps;++j) {
+                       lCurrentValue = lMatrix[lIndex];
+                       lIndex += pNbComps;
+                       lNorms[i] += lCurrentValue * lCurrentValue;
+               }
+               lNorms[i] = sqrt(lNorms[i]);
+       }
+}