Makes block switching code a lot uglier -- still more work to do.
authorJean-Marc Valin <jmvalin@jmvalin.ca>
Sun, 26 May 2013 03:33:13 +0000 (23:33 -0400)
committerJean-Marc Valin <jmvalin@jmvalin.ca>
Sun, 26 May 2013 03:45:45 +0000 (23:45 -0400)
src/block_size.c

index f385687..1562fe7 100644 (file)
@@ -34,20 +34,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.*/
 #define CG32 (17.1/6)
 
 /* Tuning parameter for block decision (higher values results in smaller blocks) */
-#define PSY_LAMBDA .65
+#define PSY_LAMBDA (.65)
 
 /* Weighting of the 8x8 masking compared to 4x4 */
-#define PSY8_FUDGE .5f
+#define PSY8_FUDGE (.5f)
 
 /* This advanced macro computes the product of x by itself, otherwise known as
    raising to the power of two, squaring, or inverse square-root. It can be
    used to square integers, but not circles. */
 #define SQUARE(x) ((int)(x)*(int)(x))
 
-void compute_stats(const unsigned char *img,int stride,BlockStats *stats)
+static void compute_stats(const unsigned char *img, int stride, BlockStats *stats)
 {
   const unsigned char *x;
-  int i, j;
+  int i;
+  int j;
   int off8;
   ogg_int32_t (*Sx2)[SIZE2_SUMS];
   ogg_int32_t (*Sxx2)[SIZE2_SUMS];
@@ -71,49 +72,52 @@ void compute_stats(const unsigned char *img,int stride,BlockStats *stats)
   Var8 = stats->Var8;
   invVar8 = stats->invVar8;
 
-  x = img-BLOCK_OFFSET(stride);
-  for(i=0;i<SIZE2_SUMS;i++){
-    for(j=0;j<SIZE2_SUMS;j++){
-      Sx2 [i][j]=x[2*j]+x[2*j+1]+x[2*j+stride]+x[2*j+stride+1];
-      Sxx2[i][j]=SQUARE(x[2*j])+SQUARE(x[2*j+1])+SQUARE(x[2*j+stride])+SQUARE(x[2*j+stride+1]);
+  x = img - BLOCK_OFFSET(stride);
+  for (i = 0; i < SIZE2_SUMS; i++) {
+    for (j = 0; j < SIZE2_SUMS; j++) {
+      Sx2 [i][j] = x[2*j] + x[2*j + 1] + x[2*j + stride] + x[2*j+stride + 1];
+      Sxx2[i][j] = SQUARE(x[2*j]) + SQUARE(x[2*j + 1])
+       + SQUARE(x[2*j + stride]) + SQUARE(x[2*j + stride + 1]);
     }
-    x+=2*stride;
+    x += 2*stride;
   }
 
-  for(i=0;i<SIZE4_SUMS;i++){
-    for(j=0;j<SIZE4_SUMS;j++){
-      Sx4 [i][j]=Sx2 [i][j]+Sx2 [i][j+1]+Sx2 [i+1][j]+Sx2 [i+1][j+1];
-      Sxx4[i][j]=Sxx2[i][j]+Sxx2[i][j+1]+Sxx2[i+1][j]+Sxx2[i+1][j+1];
+  for (i=0; i<SIZE4_SUMS; i++) {
+    for (j=0; j<SIZE4_SUMS; j++) {
+      Sx4[i][j] = Sx2[i][j] + Sx2[i][j + 1]
+       + Sx2[i + 1][j] + Sx2[i + 1][j + 1];
+      Sxx4[i][j] = Sxx2[i][j] + Sxx2[i][j + 1]
+       + Sxx2[i + 1][j] + Sxx2[i + 1][j + 1];
     }
   }
 
-  off8 = OFF32-2*OFF8_32;
-  OD_ASSERT(off8>=0);
-  for(i=0;i<SIZE8_SUMS;i++){
-    for(j=0;j<SIZE8_SUMS;j++){
-      Sx8 [i][j]=Sx4 [2*i+  off8][2*j+off8]+Sx4 [2*i+  off8][2*j+2+off8]
-                +Sx4 [2*i+2+off8][2*j+off8]+Sx4 [2*i+2+off8][2*j+2+off8];
-      Sxx8[i][j]=Sxx4[2*i+  off8][2*j+off8]+Sxx4[2*i+  off8][2*j+2+off8]
-                +Sxx4[2*i+2+off8][2*j+off8]+Sxx4[2*i+2+off8][2*j+2+off8];
+  off8 = OFF32 - 2*OFF8_32;
+  OD_ASSERT(off8 >= 0);
+  for (i = 0; i < SIZE8_SUMS; i++) {
+    for (j = 0; j < SIZE8_SUMS; j++) {
+      Sx8[i][j] = Sx4[2*i + off8][2*j+off8] + Sx4[2*i + off8][2*j + 2 + off8]
+       + Sx4[2*i + 2 + off8][2*j + off8] + Sx4[2*i + 2 + off8][2*j + 2 + off8];
+      Sxx8[i][j] = Sxx4[2*i + off8][2*j + off8] + Sxx4[2*i + off8][2*j + 2 + off8]
+       + Sxx4[2*i + 2 + off8][2*j + off8] + Sxx4[2*i + 2 + off8][2*j + 2 + off8];
     }
   }
 
-  for(i=0;i<SIZE4_SUMS;i++){
-    for(j=0;j<SIZE4_SUMS;j++){
+  for (i = 0; i < SIZE4_SUMS; i++) {
+    for (j = 0; j < SIZE4_SUMS; j++) {
       ogg_int32_t var_floor;
-      Var4[i][j] = (Sxx4[i][j]-(SQUARE(Sx4[i][j])>>4))>>5;
-      var_floor = 4+(Sx4[i][j]>>8);
-      if (Var4[i][j]<var_floor)Var4[i][j]=var_floor;
+      Var4[i][j] = (Sxx4[i][j] - (SQUARE(Sx4[i][j]) >> 4)) >> 5;
+      var_floor = 4 + (Sx4[i][j] >> 8);
+      if (Var4[i][j] < var_floor) Var4[i][j] = var_floor;
       invVar4[i][j] = 16384/Var4[i][j];
     }
   }
 
-  for(i=0;i<SIZE8_SUMS;i++){
-    for(j=0;j<SIZE8_SUMS;j++){
+  for (i = 0; i < SIZE8_SUMS; i++){
+    for (j = 0; j < SIZE8_SUMS; j++){
       ogg_int32_t var_floor;
-      Var8[i][j] = (Sxx8[i][j]-(SQUARE(Sx8[i][j])>>6))>>5;
-      var_floor = 4+(Sx8[i][j]>>8);
-      if (Var8[i][j]<var_floor)Var8[i][j]=var_floor;
+      Var8[i][j] = (Sxx8[i][j] - (SQUARE(Sx8[i][j]) >> 6)) >> 5;
+      var_floor = 4 + (Sx8[i][j] >> 8);
+      if (Var8[i][j] < var_floor) Var8[i][j] = var_floor;
       invVar8[i][j] = 16384/Var8[i][j];
     }
   }
@@ -132,92 +136,83 @@ void compute_stats(const unsigned char *img,int stride,BlockStats *stats)
 void process_block_size32(BlockSizeComp *bs, const unsigned char *psy_img,
     const unsigned char *img, int stride, int dec[4][4])
 {
-  int i,j;
+  int i;
+  int j;
   compute_stats(img, stride, &bs->img_stats);
-  if (psy_img != img)
-    compute_stats(psy_img, stride, &bs->psy_stats);
-  else
-    memcpy(&bs->psy_stats, &bs->img_stats, sizeof(BlockStats));
+  if (psy_img != img) compute_stats(psy_img, stride, &bs->psy_stats);
+  else memcpy(&bs->psy_stats, &bs->img_stats, sizeof(BlockStats));
 
   /* Compute 4x4 masking */
-  for(i=0;i<8;i++)
-  {
-    for(j=0;j<8;j++)
-    {
-      int k,m;
+  for (i = 0; i < 8; i++) {
+    for (j = 0; j < 8; j++) {
+      int k;
+      int m;
       ogg_int32_t sum_var=0;
       float psy=0;
 
       /* Masking based on 4x4 variances */
-      for(k=0;k<3;k++)
-      {
-        for(m=0;m<3;m++)
-        {
-          sum_var += bs->img_stats.Var4[2*i+k+OFF32-1][2*j+m+OFF32-1];
+      for (k = 0; k < 3; k++) {
+        for (m = 0; m < 3; m++) {
+          sum_var += bs->img_stats.Var4[2*i + k + OFF32 - 1][2*j + m + OFF32 - 1];
         }
       }
       bs->noise4_4[i][j] = sum_var/(3*3);
-      for(k=0;k<3;k++)
-      {
-        for(m=0;m<3;m++)
-        {
-          psy += OD_LOG2(1+bs->noise4_4[i][j]*bs->psy_stats.invVar4[2*i+k+OFF32-1][2*j+m+OFF32-1]/16384.);
+      for (k = 0; k < 3; k++) {
+        for (m = 0; m < 3; m++) {
+          psy += OD_LOG2(1 + bs->noise4_4[i][j]*bs->psy_stats.invVar4
+           [2*i + k + OFF32 - 1][2*j + m + OFF32 - 1]/16384.);
         }
       }
-      bs->psy4[i][j] = psy/(3*3)-1.;
+      bs->psy4[i][j] = psy/(3*3) - 1.;
     }
   }
 
 
   /* Compute 8x8 masking and make 4x4 vs 8x8 decision */
-  for(i=0;i<4;i++)
-  {
-    for(j=0;j<4;j++)
-    {
-      int k,m;
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      int k;
+      int m;
       float gain4, gain8;
       float psy4_avg;
       ogg_int32_t sum_var=0;
       float psy=0;
 
       /* Masking based on 4x4 variances */
-      for(k=0;k<COUNT8;k++)
-      {
-        for(m=0;m<COUNT8;m++)
-        {
-          sum_var += bs->img_stats.Var4[4*i+k+OFF32-OFF8][4*j+m+OFF32-OFF8];
+      for (k = 0; k < COUNT8; k++) {
+        for (m = 0; m < COUNT8; m++) {
+          sum_var += bs->img_stats.Var4[4*i + k + OFF32 - OFF8][4*j + m + OFF32 - OFF8];
         }
       }
       bs->noise4_8[i][j] = sum_var/(COUNT8*COUNT8);
-      for(k=0;k<COUNT8;k++)
-      {
-        for(m=0;m<COUNT8;m++)
-        {
-          psy += OD_LOG2(1+bs->noise4_8[i][j]*bs->img_stats.invVar4[4*i+k+OFF32-OFF8][4*j+m+OFF32-OFF8]/16384.);
+      for (k = 0; k < COUNT8; k++) {
+        for(m = 0; m < COUNT8; m++) {
+          psy += OD_LOG2(1 + bs->noise4_8[i][j]*bs->img_stats.invVar4
+           [4*i + k + OFF32 - OFF8]
+           [4*j + m + OFF32 - OFF8]/16384.);
         }
       }
-      bs->psy8[i][j] = psy/(COUNT8*COUNT8)-1.;
-      psy4_avg = .25*(bs->psy4[2*i][2*j]+bs->psy4[2*i][2*j+1]+bs->psy4[2*i+1][2*j]+bs->psy4[2*i+1][2*j+1]);
+      bs->psy8[i][j] = psy/(COUNT8*COUNT8) - 1.;
+      psy4_avg = .25*(bs->psy4[2*i][2*j] + bs->psy4[2*i][2*j + 1]
+       + bs->psy4[2*i + 1][2*j] + bs->psy4[2*i + 1][2*j + 1]);
       gain4 = CG4 - PSY_LAMBDA*(psy4_avg);
       gain8 = CG8 - PSY_LAMBDA*(bs->psy8[i][j]);
-      if (gain8>=gain4)
-      {
+      if (gain8 >= gain4) {
         dec[i][j] = 1;
         bs->dec_gain8[i][j] = gain8;
-      } else {
+      }
+      else {
         dec[i][j] = 0;
         bs->dec_gain8[i][j] = gain4;
       }
-
     }
   }
 
   /* Compute 16x16 masking and make 4x4/8x8 vs 16x16 decision */
-  for(i=0;i<2;i++)
-  {
-    for(j=0;j<2;j++)
-    {
-      int k,m;
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      int k;
+      int m;
       float gain16;
       float gain8_avg;
       ogg_int32_t sum_var=0;
@@ -225,49 +220,48 @@ void process_block_size32(BlockSizeComp *bs, const unsigned char *psy_img,
       float psy8=0;
 
       /* Masking based on 4x4 variances */
-      for(k=0;k<COUNT16;k++)
-      {
-        for(m=0;m<COUNT16;m++)
-        {
-          sum_var += bs->img_stats.Var4[8*i+k+OFF32-OFF16][8*j+m+OFF32-OFF16];
+      for (k = 0; k < COUNT16; k++) {
+        for (m = 0; m < COUNT16; m++) {
+          sum_var += bs->img_stats.Var4[8*i + k + OFF32 - OFF16]
+           [8*j + m + OFF32 - OFF16];
         }
       }
       bs->noise4_16[i][j] = sum_var/(COUNT16*COUNT16);
-      for(k=0;k<COUNT16;k++)
-      {
-        for(m=0;m<COUNT16;m++)
-        {
-          psy += OD_LOG2(1+bs->noise4_16[i][j]*bs->img_stats.invVar4[8*i+k+OFF32-OFF16][8*j+m+OFF32-OFF16]/16384.);
+      for (k = 0; k < COUNT16; k++) {
+        for (m = 0; m < COUNT16; m++) {
+          psy += OD_LOG2(1 + bs->noise4_16[i][j]*bs->img_stats.invVar4
+           [8*i + k + OFF32 - OFF16][8*j + m + OFF32 - OFF16]/16384.);
         }
       }
-      bs->psy16[i][j] = psy/(COUNT16*COUNT16)-1.;
+      bs->psy16[i][j] = psy/(COUNT16*COUNT16) - 1.;
 
       sum_var = 0;
       /* Use 8x8 variances */
-      for(k=0;k<COUNT8_16;k++)
-      {
-        for(m=0;m<COUNT8_16;m++)
-        {
-          sum_var += bs->img_stats.Var8[4*i+k+OFF8_32-OFF8_16][4*j+m+OFF8_32-OFF8_16];
+      for (k = 0; k < COUNT8_16; k++) {
+        for (m = 0; m < COUNT8_16; m++) {
+          sum_var += bs->img_stats.Var8[4*i + k + OFF8_32 - OFF8_16]
+           [4*j + m + OFF8_32 - OFF8_16];
         }
       }
       bs->noise8_16[i][j] = sum_var/(COUNT8_16*COUNT8_16);
-      for(k=0;k<COUNT8_16;k++)
-      {
-        for(m=0;m<COUNT8_16;m++)
-        {
-          psy8 += OD_LOG2(1+bs->noise8_16[i][j]*bs->img_stats.invVar8[4*i+k+OFF8_32-OFF8_16][4*j+m+OFF8_32-OFF8_16]/16384.);
+      for (k = 0 ; k < COUNT8_16; k++) {
+        for (m = 0; m < COUNT8_16; m++) {
+          psy8 += OD_LOG2(1 + bs->noise8_16[i][j]*bs->img_stats.invVar8
+           [4*i + k + OFF8_32 - OFF8_16][4*j + m + OFF8_32 - OFF8_16]/16384.);
         }
       }
-      bs->psy16[i][j] = OD_MAXF(bs->psy16[i][j], PSY8_FUDGE*(psy8/(COUNT8_16*COUNT8_16)-1.));
+      bs->psy16[i][j] = OD_MAXF(bs->psy16[i][j], PSY8_FUDGE*
+       (psy8/(COUNT8_16*COUNT8_16) - 1.));
 
-      gain8_avg = .25*(bs->dec_gain8[2*i][2*j]+bs->dec_gain8[2*i][2*j+1]+bs->dec_gain8[2*i+1][2*j]+bs->dec_gain8[2*i+1][2*j+1]);
+      gain8_avg = .25*(bs->dec_gain8[2*i][2*j] + bs->dec_gain8[2*i][2*j + 1]
+       + bs->dec_gain8[2*i + 1][2*j] + bs->dec_gain8[2*i + 1][2*j + 1]);
       gain16 = CG16 - PSY_LAMBDA*(bs->psy16[i][j]);
-      if (gain16>=gain8_avg)
-      {
-        dec[2*i][2*j] = dec[2*i][2*j+1] = dec[2*i+1][2*j] = dec[2*i+1][2*j+1] = 2;
+      if (gain16 >= gain8_avg) {
+        dec[2*i][2*j] = dec[2*i][2*j + 1]
+         = dec[2*i + 1][2*j] = dec[2*i + 1][2*j + 1] = 2;
         bs->dec_gain16[i][j] = gain16;
-      } else {
+      }
+      else {
         bs->dec_gain16[i][j] = gain8_avg;
       }
 
@@ -276,7 +270,8 @@ void process_block_size32(BlockSizeComp *bs, const unsigned char *psy_img,
 
   /* Compute 32x32 masking and make final 4x4/8x8/16x16 vs 32x32 decision */
   {
-    int k,m;
+    int k;
+    int m;
     float gain32;
     float gain16_avg;
     ogg_int32_t sum_var=0;
@@ -284,50 +279,40 @@ void process_block_size32(BlockSizeComp *bs, const unsigned char *psy_img,
     float psy8=0;
 
     /* Masking based on 4x4 variances */
-    for(k=0;k<COUNT32;k++)
-    {
-      for(m=0;m<COUNT32;m++)
-      {
+    for (k = 0; k < COUNT32; k++) {
+      for (m = 0; m < COUNT32; m++) {
         sum_var += bs->img_stats.Var4[k][m];
       }
     }
     bs->noise4_32 = sum_var/(COUNT32*COUNT32);
-    for(k=0;k<COUNT32;k++)
-    {
-      for(m=0;m<COUNT32;m++)
-      {
-        psy += OD_LOG2(1+bs->noise4_32*bs->img_stats.invVar4[k][m]/16384.);
+    for (k = 0; k < COUNT32; k++) {
+      for (m = 0; m < COUNT32; m++) {
+        psy += OD_LOG2(1 + bs->noise4_32*bs->img_stats.invVar4[k][m]/16384.);
       }
     }
-    bs->psy32 = psy/(COUNT32*COUNT32)-1.;
+    bs->psy32 = psy/(COUNT32*COUNT32) - 1.;
 
     sum_var = 0;
     /* Use 8x8 variances */
-    for(k=0;k<COUNT8_32;k++)
-    {
-      for(m=0;m<COUNT8_32;m++)
-      {
+    for (k = 0; k < COUNT8_32; k++) {
+      for (m = 0; m < COUNT8_32; m++) {
         sum_var += bs->img_stats.Var8[k][m];
       }
     }
     bs->noise8_32 = sum_var/(COUNT8_32*COUNT8_32);
-    for(k=0;k<COUNT8_32;k++)
-    {
-      for(m=0;m<COUNT8_32;m++)
-      {
-        psy8 += OD_LOG2(1+bs->noise8_32*bs->img_stats.invVar8[k][m]/16384.);
+    for (k=0; k < COUNT8_32; k++) {
+      for (m = 0; m < COUNT8_32; m++) {
+        psy8 += OD_LOG2(1 + bs->noise8_32*bs->img_stats.invVar8[k][m]/16384.);
       }
     }
-    bs->psy32 = OD_MAXF(bs->psy32, PSY8_FUDGE*(psy8/(COUNT8_32*COUNT8_32)-1.));
+    bs->psy32 = OD_MAXF(bs->psy32, PSY8_FUDGE*(psy8/(COUNT8_32*COUNT8_32) - 1.));
 
 
-    gain16_avg = .25*(bs->dec_gain16[0][0]+bs->dec_gain16[0][1]+bs->dec_gain16[1][0]+bs->dec_gain16[1][1]);
+    gain16_avg = .25*(bs->dec_gain16[0][0] + bs->dec_gain16[0][1]
+     + bs->dec_gain16[1][0] + bs->dec_gain16[1][1]);
     gain32 = CG32 - PSY_LAMBDA*(bs->psy32);
-    if (gain32>=gain16_avg)
-    {
-      for (k=0;k<4;k++)
-        for (m=0;m<4;m++)
-          dec[k][m] = 3;
+    if (gain32 >= gain16_avg) {
+      for (k = 0; k < 4; k++) for (m = 0; m < 4; m++) dec[k][m] = 3;
     }
 
   }