WIP: new image_header struct is used and enable used of cstr_info

[openjpeg.git] / libopenjpeg / mct.c

diff --git a/libopenjpeg/mct.c b/libopenjpeg/mct.c
index fad9355229c634eacb80f074394ab861b8c8a7c8..828b42d1f257e70da3c0120f3ab9192c5f5601b9 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> */
@@ -44,16 +48,20 @@ static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
 /* <summary> */
 /* Foward reversible MCT. */
 /* </summary> */
-void mct_encode(int *c0, int *c1, int *c2, int n) {
+void mct_encode(
+               int* restrict c0,
+               int* restrict c1,
+               int* restrict c2,
+               int n)
+{
        int i;
-       for (i = 0; i < n; i++) {
-               int r, g, b, y, u, v;
-               r = c0[i];
-               g = c1[i];
-               b = c2[i];
-               y = (r + (g << 1) + b) >> 2;
-               u = b - g;
-               v = r - g;
+       for(i = 0; i < n; ++i) {
+               int r = c0[i];
+               int g = c1[i];
+               int b = c2[i];
+               int y = (r + (g * 2) + b) >> 2;
+               int u = b - g;
+               int v = r - g;
                c0[i] = y;
                c1[i] = u;
                c2[i] = v;
@@ -63,16 +71,20 @@ void mct_encode(int *c0, int *c1, int *c2, int n) {
 /* <summary> */
 /* Inverse reversible MCT. */
 /* </summary> */
-void mct_decode(int *c0, int *c1, int *c2, int n) {
+void mct_decode(
+               int* restrict c0,
+               int* restrict c1, 
+               int* restrict c2, 
+               int n)
+{
        int i;
-       for (i = 0; i < n; i++) {
-               int y, u, v, r, g, b;
-               y = c0[i];
-               u = c1[i];
-               v = c2[i];
-               g = y - ((u + v) >> 2);
-               r = v + g;
-               b = u + g;
+       for (i = 0; i < n; ++i) {
+               int y = c0[i];
+               int u = c1[i];
+               int v = c2[i];
+               int g = y - ((u + v) >> 2);
+               int r = v + g;
+               int b = u + g;
                c0[i] = r;
                c1[i] = g;
                c2[i] = b;
@@ -89,16 +101,20 @@ double mct_getnorm(int compno) {
 /* <summary> */
 /* Foward irreversible MCT. */
 /* </summary> */
-void mct_encode_real(int *c0, int *c1, int *c2, int n) {
+void mct_encode_real(
+               int* restrict c0,
+               int* restrict c1,
+               int* restrict c2,
+               int n)
+{
        int i;
-       for (i = 0; i < n; i++) {
-               int r, g, b, y, u, v;
-               r = c0[i];
-               g = c1[i];
-               b = c2[i];
-               y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
-               u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
-               v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
+       for(i = 0; i < n; ++i) {
+               int r = c0[i];
+               int g = c1[i];
+               int b = c2[i];
+               int y =  fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
+               int u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
+               int v =  fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
                c0[i] = y;
                c1[i] = u;
                c2[i] = v;
@@ -108,16 +124,58 @@ void mct_encode_real(int *c0, int *c1, int *c2, int n) {
 /* <summary> */
 /* Inverse irreversible MCT. */
 /* </summary> */
-void mct_decode_real(int *c0, int *c1, int *c2, int n) {
+void mct_decode_real(
+               float* restrict c0,
+               float* restrict c1,
+               float* restrict c2,
+               int n)
+{
        int i;
-       for (i = 0; i < n; i++) {
-               int y, u, v, r, g, b;
-               y = c0[i];
-               u = c1[i];
-               v = c2[i];
-               r = y + fix_mul(v, 11485);
-               g = y - fix_mul(u, 2819) - fix_mul(v, 5850);
-               b = y + fix_mul(u, 14516);
+#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];
+               float v = c2[i];
+               float r = y + (v * 1.402f);
+               float g = y - (u * 0.34413f) - (v * (0.71414f));
+               float b = y + (u * 1.772f);
                c0[i] = r;
                c1[i] = g;
                c2[i] = b;
@@ -130,3 +188,58 @@ void mct_decode_real(int *c0, int *c1, int *c2, int n) {
 double mct_getnorm_real(int compno) {
        return mct_norms_real[compno];
 }
+
+
+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;
+}