gst/monoscope/monoscope.c

   1 /*  monoscope.cpp
   2  *  Copyright (C) 2002 Richard Boulton <richard@tartarus.org>
   3  *  Copyright (C) 1998-2001 Andy Lo A Foe <andy@alsaplayer.org>
   4  *  Original code by Tinic Uro
   5  *
   6  *  This code is copied from Alsaplayer.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include "monoscope.h"
  28
  29 #include <string.h>
  30 #include <stdlib.h>
  31
  32 static void
  33 colors_init (guint32 * colors)
  34 {
  35   int i;
  36
  37   for (i = 0; i < 32; i++) {
  38     colors[i] = (i * 8 << 16) + (255 << 8);
  39     colors[i + 31] = (255 << 16) + (((31 - i) * 8) << 8);
  40   }
  41   colors[63] = (40 << 16) + (75 << 8);
  42 }
  43
  44 struct monoscope_state *
  45 monoscope_init (guint32 resx, guint32 resy)
  46 {
  47   struct monoscope_state *stateptr;
  48   stateptr = calloc (1, sizeof (struct monoscope_state));
  49   if (stateptr == 0)
  50     return 0;
  51   stateptr->cstate = convolve_init ();
  52   colors_init (stateptr->colors);
  53   return stateptr;
  54 }
  55
  56 guint32 *
  57 monoscope_update (struct monoscope_state * stateptr, gint16 data[512])
  58 {
  59   /* Note that CONVOLVE_BIG must == data size here, ie 512. */
  60   /* Really, we want samples evenly spread over the available data.
  61    * Just taking a continuous chunk will do for now, though. */
  62   int i;
  63   int foo;
  64   int bar;
  65   int h;
  66   guint32 *loc;
  67
  68   int factor;
  69   int val;
  70   int max = 1;
  71   short *thisEq;
  72
  73   memcpy (stateptr->copyEq, data, sizeof (short) * CONVOLVE_BIG);
  74   thisEq = stateptr->copyEq;
  75 #if 1
  76   val = convolve_match (stateptr->avgEq, stateptr->copyEq, stateptr->cstate);
  77   thisEq += val;
  78 #endif
  79   memset (stateptr->display, 0, 256 * 128 * sizeof (guint32));
  80   for (i = 0; i < 256; i++) {
  81     foo = thisEq[i] + (stateptr->avgEq[i] >> 1);
  82     stateptr->avgEq[i] = foo;
  83     if (foo < 0)
  84       foo = -foo;
  85     if (foo > max)
  86       max = foo;
  87   }
  88   stateptr->avgMax += max - (stateptr->avgMax >> 8);
  89   if (stateptr->avgMax < max)
  90     stateptr->avgMax = max;     /* Avoid overflow */
  91   factor = 0x7fffffff / stateptr->avgMax;
  92   /* Keep the scaling sensible. */
  93   if (factor > (1 << 18))
  94     factor = 1 << 18;
  95   if (factor < (1 << 8))
  96     factor = 1 << 8;
  97   for (i = 0; i < 256; i++) {
  98     foo = stateptr->avgEq[i] * factor;
  99     foo >>= 18;
 100     if (foo > 63)
 101       foo = 63;
 102     if (foo < -64)
 103       foo = -64;
 104     val = (i + ((foo + 64) << 8));
 105     bar = val;
 106     if ((bar > 0) && (bar < (256 * 128))) {
 107       loc = stateptr->display + bar;
 108       if (foo < 0) {
 109         for (h = 0; h <= (-foo); h++) {
 110           *loc = stateptr->colors[h];
 111           loc += 256;
 112         }
 113       } else {
 114         for (h = 0; h <= foo; h++) {
 115           *loc = stateptr->colors[h];
 116           loc -= 256;
 117         }
 118       }
 119     }
 120   }
 121
 122   /* Draw grid. */
 123   for (i = 16; i < 128; i += 16) {
 124     for (h = 0; h < 256; h += 2) {
 125       stateptr->display[(i << 8) + h] = stateptr->colors[63];
 126       if (i == 64)
 127         stateptr->display[(i << 8) + h + 1] = stateptr->colors[63];
 128     }
 129   }
 130   for (i = 16; i < 256; i += 16) {
 131     for (h = 0; h < 128; h += 2) {
 132       stateptr->display[i + (h << 8)] = stateptr->colors[63];
 133     }
 134   }
 135
 136   return stateptr->display;
 137 }
 138
 139 void
 140 monoscope_close (struct monoscope_state *stateptr)
 141 {
 142 }