upgrade openjpeg to commit# cf352af

third_party/libopenjpeg20/invert.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) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ skipping 85 matching lines @@
         
     return OPJ_TRUE;
 }
 
 
 /*
 ==========================================================
    Local functions
 ==========================================================
 */
-OPJ_BOOL opj_lupDecompose(OPJ_FLOAT32 * matrix,OPJ_UINT32 * permutations, 
+static OPJ_BOOL opj_lupDecompose(OPJ_FLOAT32 * matrix,OPJ_UINT32 * permutations,
                           OPJ_FLOAT32 * p_swap_area,
                           OPJ_UINT32 nb_compo) 
 {
         OPJ_UINT32 * tmpPermutations = permutations;
         OPJ_UINT32 * dstPermutations;
         OPJ_UINT32 k2=0,t;
         OPJ_FLOAT32 temp;
         OPJ_UINT32 i,j,k;
         OPJ_FLOAT32 p;
         OPJ_UINT32 lLastColum = nb_compo - 1;
         OPJ_UINT32 lSwapSize = nb_compo * (OPJ_UINT32)sizeof(OPJ_FLOAT32);
         OPJ_FLOAT32 * lTmpMatrix = matrix;
         OPJ_FLOAT32 * lColumnMatrix,* lDestMatrix;
         OPJ_UINT32 offset = 1;
         OPJ_UINT32 lStride = nb_compo-1;
 
         /*initialize permutations */
         for (i = 0; i < nb_compo; ++i) 
         {
         *tmpPermutations++ = i;
         }
-        /* now make a pivot with colum switch */
+        /* now make a pivot with column switch */
         tmpPermutations = permutations;
         for (k = 0; k < lLastColum; ++k) {
                 p = 0.0;
 
                 /* take the middle element */
                 lColumnMatrix = lTmpMatrix + k;
                 
                 /* make permutation with the biggest value in the column */
         for (i = k; i < nb_compo; ++i) {
                         temp = ((*lColumnMatrix > 0) ? *lColumnMatrix : -(*lColumnMatrix));
@@ skipping 58 matching lines @@
                 /* 1 element less for stride */
                 --lStride;
                 /* next line */
                 lTmpMatrix+=nb_compo;
                 /* next permutation element */
                 ++tmpPermutations;
         }
     return OPJ_TRUE;
 }
                 
-void opj_lupSolve (OPJ_FLOAT32 * pResult, 
+static void opj_lupSolve (OPJ_FLOAT32 * pResult,
                    OPJ_FLOAT32 * pMatrix, 
                    OPJ_FLOAT32 * pVector, 
                    OPJ_UINT32* pPermutations, 
                    OPJ_UINT32 nb_compo,OPJ_FLOAT32 * p_intermediate_data) 
 {
         OPJ_INT32 k;
     OPJ_UINT32 i,j;
         OPJ_FLOAT32 sum;
         OPJ_FLOAT32 u;
     OPJ_UINT32 lStride = nb_compo+1;
@@ skipping 41 matching lines @@
                         /* sum += matrix[k][j] * x[j] */
                 sum += (*(lTmpMatrix++)) * (*(lCurrentPtr++));
                 }
                 /*x[k] = (y[k] - sum) / u; */
         *(lBeginPtr--) = (*(lGeneratedData--) - sum) / u;
                 lLineMatrix -= lStride;
         }
 }
     
 
-void opj_lupInvert (OPJ_FLOAT32 * pSrcMatrix,
+static void opj_lupInvert (OPJ_FLOAT32 * pSrcMatrix,
                     OPJ_FLOAT32 * pDestMatrix,
                     OPJ_UINT32 nb_compo,
                     OPJ_UINT32 * pPermutations,
                     OPJ_FLOAT32 * p_src_temp,
                     OPJ_FLOAT32 * p_dest_temp,
                     OPJ_FLOAT32 * p_swap_area )
 {
         OPJ_UINT32 j,i;
         OPJ_FLOAT32 * lCurrentPtr;
         OPJ_FLOAT32 * lLineMatrix = pDestMatrix;
         OPJ_UINT32 lSwapSize = nb_compo * (OPJ_UINT32)sizeof(OPJ_FLOAT32);
 
         for (j = 0; j < nb_compo; ++j) {
                 lCurrentPtr = lLineMatrix++;
         memset(p_src_temp,0,lSwapSize);
         p_src_temp[j] = 1.0;
                 opj_lupSolve(p_dest_temp,pSrcMatrix,p_src_temp, pPermutations, nb_compo , p_swap_area);
 
                 for (i = 0; i < nb_compo; ++i) {
                 *(lCurrentPtr) = p_dest_temp[i];
                         lCurrentPtr+=nb_compo;
         }
     }
 }