Use none SSE functions when data is not 16 byte aligned

core/src/fxcodec/fx_libopenjpeg/libopenjpeg20/dwt.c

 /*
  * The copyright in this software is being made available under the 2-clauses 
  * BSD License, included below. This software may be subject to other third 
  * party and contributor rights, including patent rights, and no such rights
  * are granted under this license.
  *
  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
  * Copyright (c) 2002-2014, Professor Benoit Macq
  * Copyright (c) 2001-2003, David Janssens
  * Copyright (c) 2002-2003, Yannick Verschueren
@@ skipping 122 matching lines @@
 
 /* <summary>                             */
 /* Inverse 9-7 wavelet transform in 1-D. */
 /* </summary>                            */
 static void opj_v4dwt_decode(opj_v4dwt_t* restrict dwt);
 
 static void opj_v4dwt_interleave_h(opj_v4dwt_t* restrict w, OPJ_FLOAT32* restrict a, OPJ_INT32 x, OPJ_INT32 size);
 
 static void opj_v4dwt_interleave_v(opj_v4dwt_t* restrict v , OPJ_FLOAT32* restrict a , OPJ_INT32 x, OPJ_INT32 nb_elts_read);
 
-#ifdef __SSE__
+//#ifdef __SSE__
+// Disable __SSE__ due to bug http://crbug.com/373619. Should enable this after adding aligned malloc in memory manager
+#if 0
 static void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count, const __m128 c);
 
 static void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_INT32 m, __m128 c);
 
 #else
 static void opj_v4dwt_decode_step1(opj_v4_t* w, OPJ_INT32 count, const OPJ_FLOAT32 c);
 
 static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_INT32 m, OPJ_FLOAT32 c);
 
 #endif
@@ skipping 510 matching lines @@
         }
 
         a += v->sn * x;
         bi = v->wavelet + 1 - v->cas;
 
         for(i = 0; i < v->dn; ++i){
                 memcpy(&bi[i*2], &a[i*x], (size_t)nb_elts_read * sizeof(OPJ_FLOAT32));
         }
 }
 
-#ifdef __SSE__
-
+//#ifdef __SSE__
+// Disable __SSE__ due to bug http://crbug.com/373619. Should enable this after adding aligned malloc in memory manager
+#if 0
 void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count, const __m128 c){
         __m128* restrict vw = (__m128*) w;
         OPJ_INT32 i;
         /* 4x unrolled loop */
         for(i = 0; i < count >> 2; ++i){
                 *vw = _mm_mul_ps(*vw, c);
                 vw += 2;
                 *vw = _mm_mul_ps(*vw, c);
                 vw += 2;
                 *vw = _mm_mul_ps(*vw, c);
@@ skipping 115 matching lines @@
                 }
                 a = 0;
                 b = 1;
         }else{
                 if(!((dwt->sn > 0) || (dwt->dn > 1))) {
                         return;
                 }
                 a = 1;
                 b = 0;
         }
-#ifdef __SSE__
+
+//#ifdef __SSE__
+// Disable __SSE__ due to bug http://crbug.com/373619. Should enable this after adding aligned malloc in memory manager
+#if 0
         opj_v4dwt_decode_step1_sse(dwt->wavelet+a, dwt->sn, _mm_set1_ps(opj_K));
         opj_v4dwt_decode_step1_sse(dwt->wavelet+b, dwt->dn, _mm_set1_ps(opj_c13318));
         opj_v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, opj_int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(opj_dwt_delta));
         opj_v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, opj_int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(opj_dwt_gamma));
         opj_v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, opj_int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(opj_dwt_beta));
         opj_v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, opj_int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(opj_dwt_alpha));
 #else
         opj_v4dwt_decode_step1(dwt->wavelet+a, dwt->sn, opj_K);
         opj_v4dwt_decode_step1(dwt->wavelet+b, dwt->dn, opj_c13318);
         opj_v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, opj_int_min(dwt->sn, dwt->dn-a), opj_dwt_delta);
@@ skipping 94 matching lines @@
 
                         for(k = 0; k < rh; ++k){
                                 memcpy(&aj[k*w], &v.wavelet[k], (size_t)j * sizeof(OPJ_FLOAT32));
                         }
                 }
         }
 
         opj_aligned_free(h.wavelet);
         return OPJ_TRUE;
 }