monoscope: code cleanup

Use constants more often. Cleanup comments and add more to explain how things
work.

2 files changed, 54 insertions, 53 deletions

diff --git a/gst/monoscope/convolve.c b/gst/monoscope/convolve.c
index 972753f67..913773431 100644
--- a/gst/monoscope/convolve.c
+++ b/gst/monoscope/convolve.c
@@ -17,10 +17,10 @@
  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
- * 
+ *
  * Note: 7th December 2004: This file used to be licensed under the GPL,
  *       but we got permission from Ralp Loader to relicense it to LGPL.
- * 
+ *
  *  $Id$
  *
  */
@@ -248,18 +248,25 @@ convolve_run (stack_entry * top, unsigned size, double *scratch)
   } while (top->b.main != NULL);
 }
 
-int
-convolve_match (const int *lastchoice,
-    const short *input, convolve_state * state)
-/* lastchoice is a 256 sized array.  input is a 512 array.  We find the
- * contiguous length 256 sub-array of input that best matches lastchoice.
- * A measure of how good a sub-array is compared with the lastchoice is
- * given by the sum of the products of each pair of entries.  We maximise
+/*
+ * convolve_match:
+ * @lastchoice: an array of size SMALL.
+ * @input: an array of siue BIG (2*SMALL)
+ * @state: a (non-NULL) pointer returned by convolve_init.
+ *
+ * We find the contiguous SMALL-size sub-array of input that best matches
+ * lastchoice. A measure of how good a sub-array is compared with the lastchoice
+ * is given by the sum of the products of each pair of entries.  We maximise
  * that, by taking an appropriate convolution, and then finding the maximum
- * entry in the convolutions.  state is a (non-NULL) pointer returned by
- * convolve_init.  */
+ * entry in the convolutions.
+ *
+ * Return: the position of the best match
+ */
+int
+convolve_match (const int *lastchoice, const short *input,
+    convolve_state * state)
 {
-  double avg;
+  double avg = 0;
   double best;
   int p = 0;
   int i;
@@ -268,47 +275,45 @@ convolve_match (const int *lastchoice,
   double *scratch = state->scratch;
   stack_entry *top = state->stack + (STACK_SIZE - 1);
 
-#if 1
-  for (i = 0; i < 512; i++)
+  for (i = 0; i < CONVOLVE_BIG; i++)
     left[i] = input[i];
 
-  avg = 0;
-  for (i = 0; i < 256; i++) {
-    double a = lastchoice[255 - i];
+  for (i = 0; i < CONVOLVE_SMALL; i++) {
+    double a = lastchoice[(CONVOLVE_SMALL - 1) - i];
 
     right[i] = a;
     avg += a;
   }
-#endif
+
   /* We adjust the smaller of the two input arrays to have average
    * value 0.  This makes the eventual result insensitive to both
    * constant offsets and positive multipliers of the inputs. */
-  avg /= 256;
-  for (i = 0; i < 256; i++)
+  avg /= CONVOLVE_SMALL;
+  for (i = 0; i < CONVOLVE_SMALL; i++)
     right[i] -= avg;
   /* End-of-stack marker. */
   top[1].b.null = scratch;
   top[1].b.main = NULL;
-  /* The low 256x256, of which we want the high 256 outputs. */
+  /* The low SMALLxSMALL, of which we want the high outputs. */
   top->v.left = left;
   top->v.right = right;
-  top->v.out = right + 256;
-  convolve_run (top, 256, scratch);
+  top->v.out = right + CONVOLVE_SMALL;
+  convolve_run (top, CONVOLVE_SMALL, scratch);
 
-  /* The high 256x256, of which we want the low 256 outputs. */
-  top->v.left = left + 256;
+  /* The high SMALLxSMALL, of which we want the low outputs. */
+  top->v.left = left + CONVOLVE_SMALL;
   top->v.right = right;
   top->v.out = right;
-  convolve_run (top, 256, scratch);
+  convolve_run (top, CONVOLVE_SMALL, scratch);
 
   /* Now find the best position amoungs this.  Apart from the first
    * and last, the required convolution outputs are formed by adding
    * outputs from the two convolutions above. */
-  best = right[511];
-  right[767] = 0;
+  best = right[CONVOLVE_BIG - 1];
+  right[CONVOLVE_BIG + CONVOLVE_SMALL + 1] = 0;
   p = -1;
-  for (i = 0; i < 256; i++) {
-    double a = right[i] + right[i + 512];
+  for (i = 0; i < CONVOLVE_SMALL; i++) {
+    double a = right[i] + right[i + CONVOLVE_BIG];
 
     if (a > best) {
       best = a;
@@ -320,21 +325,19 @@ convolve_match (const int *lastchoice,
 #if 0
   {
     /* This is some debugging code... */
-    int bad = 0;
-
     best = 0;
-    for (i = 0; i < 256; i++)
+    for (i = 0; i < CONVOLVE_SMALL; i++)
       best += ((double) input[i + p]) * ((double) lastchoice[i] - avg);
 
-    for (i = 0; i < 257; i++) {
+    for (i = 0; i <= CONVOLVE_SMALL; i++) {
       double tot = 0;
       unsigned int j;
 
-      for (j = 0; j < 256; j++)
+      for (j = 0; j < CONVOLVE_SMALL; j++)
         tot += ((double) input[i + j]) * ((double) lastchoice[j] - avg);
       if (tot > best)
         printf ("(%i)", i);
-      if (tot != left[i + 255])
+      if (tot != left[i + (CONVOLVE_SMALL - 1)])
         printf ("!");
     }
 
diff --git a/gst/monoscope/monoscope.c b/gst/monoscope/monoscope.c
index 98822d322..e0c765165 100644
--- a/gst/monoscope/monoscope.c
+++ b/gst/monoscope/monoscope.c
@@ -7,9 +7,9 @@
  *  the BSD license without a advertisig clause. Andy Lo A Foe then relicensed the
  *  code when he used it for Alsaplayer to GPL with Tinic's permission. Richard Boulton
  *  then took this code and made a GPL plugin out of it.
- * 
+ *
  *  7th December 2004 Christian Schaller: Richard Boulton and Andy Lo A Foe gave
- *  permission to relicense their changes under BSD license so we where able to restore the 
+ *  permission to relicense their changes under BSD license so we where able to restore the
  *  code to Tinic's original BSD license.
  *
  * This file is under what is known as the BSD license:
@@ -17,21 +17,21 @@
  * Redistribution and use in source and binary forms, with or without modification, i
  * are permitted provided that the following conditions are met:
  *
- * 1. Redistributions of source code must retain the above copyright notice, this list of 
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
  * conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice, this list 
- * of conditions and the following disclaimer in the documentation and/or other materials 
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
  * provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products derived from 
+ * 3. The name of the author may not be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
@@ -95,14 +95,12 @@ monoscope_update (struct monoscope_state *stateptr, gint16 data[512])
   int factor;
   int val;
   int max = 1;
-  short *thisEq;
+  short *thisEq = stateptr->copyEq;
 
-  memcpy (stateptr->copyEq, data, sizeof (short) * CONVOLVE_BIG);
-  thisEq = stateptr->copyEq;
-#if 1
+  memcpy (thisEq, data, sizeof (short) * CONVOLVE_BIG);
   val = convolve_match (stateptr->avgEq, stateptr->copyEq, stateptr->cstate);
   thisEq += val;
-#endif
+
   memset (stateptr->display, 0, 256 * 128 * sizeof (guint32));
   for (i = 0; i < 256; i++) {
     foo = thisEq[i] + (stateptr->avgEq[i] >> 1);