vcs.maemo.org Git - tunertool/blob - src/gstpitch.c

   1 /* vim: set sts=2 sw=2 et: */
   2 /*
   3  * GStreamer
   4  * Copyright (C) 2006 Josep Torra <j.torra@telefonica.net>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <gst/audio/audio.h>
  27
  28 #include "gstpitch.h"
  29
  30 GST_DEBUG_CATEGORY_STATIC (gst_pitch_debug);
  31 #define GST_CAT_DEFAULT gst_pitch_debug
  32
  33 #define RATE    8000
  34 #define WANTED  RATE * 2
  35
  36 /* Filter signals and args */
  37 enum
  38 {
  39   PROP_0,
  40   PROP_SIGNAL_FFREQ,
  41   PROP_SIGNAL_INTERVAL,
  42   PROP_SIGNAL_MINFREQ,
  43   PROP_SIGNAL_MAXFREQ,
  44   PROP_NFFT,
  45   PROP_ALGORITHM
  46 };
  47
  48 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  49     GST_PAD_SINK,
  50     GST_PAD_ALWAYS,
  51     GST_STATIC_CAPS ("audio/x-raw-int, "
  52         "rate = (int) 8000, "
  53         "channels = (int) 1, "
  54         "endianness = (int) BYTE_ORDER, "
  55         "width = (int) 16, " "depth = (int) 16, " "signed = (boolean) true")
  56     );
  57
  58 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  59     GST_PAD_SRC,
  60     GST_PAD_ALWAYS,
  61     GST_STATIC_CAPS ("audio/x-raw-int, "
  62         "rate = (int) [ 1, MAX ], "
  63         "channels = (int) [1, MAX], "
  64         "endianness = (int) BYTE_ORDER, "
  65         "width = (int) 16, " "depth = (int) 16, " "signed = (boolean) true")
  66     );
  67
  68 #define DEBUG_INIT(bla) \
  69   GST_DEBUG_CATEGORY_INIT (gst_pitch_debug, "Pitch", 0, "fundamental frequency plugin");
  70
  71 GST_BOILERPLATE_FULL (GstPitch, gst_pitch, GstBaseTransform,
  72     GST_TYPE_BASE_TRANSFORM, DEBUG_INIT);
  73
  74 static void gst_pitch_set_property (GObject * object, guint prop_id,
  75     const GValue * value, GParamSpec * pspec);
  76 static void gst_pitch_get_property (GObject * object, guint prop_id,
  77     GValue * value, GParamSpec * pspec);
  78 static void gst_pitch_dispose (GObject * object);
  79
  80 static gboolean gst_pitch_set_caps (GstBaseTransform * trans, GstCaps * in,
  81     GstCaps * out);
  82 static gboolean gst_pitch_start (GstBaseTransform * trans);
  83
  84 static GstFlowReturn gst_pitch_transform_ip (GstBaseTransform * trans,
  85     GstBuffer * in);
  86
  87 #define DEFAULT_PROP_ALGORITHM GST_PITCH_ALGORITHM_FFT
  88
  89 #define GST_TYPE_PITCH_ALGORITHM (gst_pitch_algorithm_get_type())
  90 static GType
  91 gst_pitch_algorithm_get_type (void)
  92 {
  93   static GType pitch_algorithm_type = 0;
  94   static const GEnumValue pitch_algorithm[] = {
  95     {GST_PITCH_ALGORITHM_FFT, "fft", "fft"},
  96     {GST_PITCH_ALGORITHM_HPS, "hps", "hps"},
  97     {0, NULL, NULL},
  98   };
  99
 100   if (!pitch_algorithm_type) {
 101     pitch_algorithm_type =
 102         g_enum_register_static ("GstPitchAlgorithm",
 103         pitch_algorithm);
 104   }
 105   return pitch_algorithm_type;
 106 }
 107
 108 /* GObject vmethod implementations */
 109
 110 static void
 111 gst_pitch_base_init (gpointer klass)
 112 {
 113   static GstElementDetails element_details = {
 114     "Pitch analyzer",
 115     "Filter/Analyzer/Audio",
 116     "Run an FFT on the audio signal, output fundamental frequency",
 117     "Josep Torra <j.torra@telefonica.net>"
 118   };
 119   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 120
 121   gst_element_class_add_pad_template (element_class,
 122       gst_static_pad_template_get (&src_template));
 123   gst_element_class_add_pad_template (element_class,
 124       gst_static_pad_template_get (&sink_template));
 125   gst_element_class_set_details (element_class, &element_details);
 126 }
 127
 128 static void
 129 gst_pitch_class_init (GstPitchClass * klass)
 130 {
 131   GObjectClass *gobject_class;
 132   GstBaseTransformClass *trans_class = GST_BASE_TRANSFORM_CLASS (klass);
 133
 134   gobject_class = (GObjectClass *) klass;
 135   gobject_class->set_property = gst_pitch_set_property;
 136   gobject_class->get_property = gst_pitch_get_property;
 137   gobject_class->dispose = gst_pitch_dispose;
 138
 139   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_pitch_set_caps);
 140   trans_class->start = GST_DEBUG_FUNCPTR (gst_pitch_start);
 141   trans_class->transform_ip = GST_DEBUG_FUNCPTR (gst_pitch_transform_ip);
 142   trans_class->passthrough_on_same_caps = TRUE;
 143
 144   g_object_class_install_property (gobject_class, PROP_SIGNAL_FFREQ,
 145       g_param_spec_boolean ("message", "Message",
 146           "Post a fundamental frequency message for each passed interval",
 147           TRUE, G_PARAM_READWRITE));
 148
 149   g_object_class_install_property (gobject_class, PROP_SIGNAL_MINFREQ,
 150       g_param_spec_int ("minfreq", "MinFreq",
 151           "Initial scan frequency, default 30 Hz",
 152           1, G_MAXINT, 30, G_PARAM_READWRITE));
 153
 154   g_object_class_install_property (gobject_class, PROP_SIGNAL_MAXFREQ,
 155       g_param_spec_int ("maxfreq", "MaxFreq",
 156           "Final scan frequency, default 1500 Hz",
 157           1, G_MAXINT, 1500, G_PARAM_READWRITE));
 158
 159   g_object_class_install_property (gobject_class, PROP_ALGORITHM,
 160       g_param_spec_enum ("algorithm", "Algorithm",
 161           "Pitch detection algorithm to use",
 162           GST_TYPE_PITCH_ALGORITHM, DEFAULT_PROP_ALGORITHM,
 163           G_PARAM_READWRITE));
 164
 165
 166   GST_BASE_TRANSFORM_CLASS (klass)->transform_ip =
 167       GST_DEBUG_FUNCPTR (gst_pitch_transform_ip);
 168 }
 169
 170 static void
 171 gst_pitch_setup_algorithm (GstPitch * filter)
 172 {
 173   if (filter->algorithm == GST_PITCH_ALGORITHM_HPS) {
 174     filter->module = (gint *) g_malloc (RATE * sizeof (gint));
 175   }
 176   else {
 177     if (filter->module)
 178       g_free (filter->module);
 179
 180     filter->module = NULL;
 181   }
 182 }
 183
 184 static void
 185 gst_pitch_init (GstPitch * filter, GstPitchClass * klass)
 186 {
 187   filter->adapter = gst_adapter_new ();
 188
 189   filter->minfreq = 30;
 190   filter->maxfreq = 1500;
 191   filter->message = TRUE;
 192   filter->algorithm = DEFAULT_PROP_ALGORITHM;
 193   gst_pitch_setup_algorithm (filter);
 194 }
 195
 196 static void
 197 gst_pitch_dispose (GObject * object)
 198 {
 199   GstPitch *filter = GST_PITCH (object);
 200
 201   if (filter->adapter) {
 202     g_object_unref (filter->adapter);
 203     filter->adapter = NULL;
 204   }
 205
 206   g_free (filter->fft_cfg);
 207   g_free (filter->signal);
 208   g_free (filter->spectrum);
 209   if (filter->module)
 210     g_free (filter->module);
 211
 212   kiss_fft_cleanup ();
 213
 214   G_OBJECT_CLASS (parent_class)->dispose (object);
 215 }
 216
 217 static void
 218 gst_pitch_set_property (GObject * object, guint prop_id,
 219     const GValue * value, GParamSpec * pspec)
 220 {
 221   GstPitch *filter = GST_PITCH (object);
 222
 223   switch (prop_id) {
 224     case PROP_SIGNAL_FFREQ:
 225       filter->message = g_value_get_boolean (value);
 226       break;
 227     case PROP_SIGNAL_MINFREQ:
 228       filter->minfreq = g_value_get_int (value);
 229       break;
 230     case PROP_SIGNAL_MAXFREQ:
 231       filter->maxfreq = g_value_get_int (value);
 232       break;
 233     case PROP_ALGORITHM:
 234       filter->algorithm = g_value_get_enum (value);
 235       gst_pitch_setup_algorithm (filter);
 236       break;
 237     default:
 238       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 239       break;
 240   }
 241 }
 242
 243 static void
 244 gst_pitch_get_property (GObject * object, guint prop_id,
 245     GValue * value, GParamSpec * pspec)
 246 {
 247   GstPitch *filter = GST_PITCH (object);
 248
 249   switch (prop_id) {
 250     case PROP_SIGNAL_FFREQ:
 251       g_value_set_boolean (value, filter->message);
 252       break;
 253     case PROP_SIGNAL_MINFREQ:
 254       g_value_set_int (value, filter->minfreq);
 255       break;
 256     case PROP_SIGNAL_MAXFREQ:
 257       g_value_set_int (value, filter->maxfreq);
 258       break;
 259     case PROP_ALGORITHM:
 260       g_value_set_enum (value, filter->algorithm);
 261       break;
 262     default:
 263       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 264       break;
 265   }
 266 }
 267
 268 static gboolean
 269 gst_pitch_set_caps (GstBaseTransform * trans, GstCaps * in, GstCaps * out)
 270 {
 271   GstPitch *filter = GST_PITCH (trans);
 272
 273   filter->fft_cfg = kiss_fft_alloc (RATE, 0, NULL, NULL);
 274   filter->signal =
 275       (kiss_fft_cpx *) g_malloc (RATE * sizeof (kiss_fft_cpx));
 276   filter->spectrum =
 277       (kiss_fft_cpx *) g_malloc (RATE * sizeof (kiss_fft_cpx));
 278
 279   return TRUE;
 280 }
 281
 282 static gboolean
 283 gst_pitch_start (GstBaseTransform * trans)
 284 {
 285   GstPitch *filter = GST_PITCH (trans);
 286
 287   gst_adapter_clear (filter->adapter);
 288
 289   return TRUE;
 290 }
 291
 292 static GstMessage *
 293 gst_pitch_message_new (GstPitch * filter)
 294 {
 295   GstStructure *s;
 296   gint i, min_i, max_i;
 297   gint frequency, frequency_module;
 298
 299   /* Extract fundamental frequency */
 300   frequency = 0;
 301   frequency_module = 0;
 302   min_i = filter->minfreq;
 303   max_i = filter->maxfreq;
 304
 305   GST_DEBUG_OBJECT (filter, "min_freq = %d, max_freq = %d", filter->minfreq,
 306       filter->maxfreq);
 307   /*GST_DEBUG_OBJECT (filter, "min_i = %d, max_i = %d", min_i, max_i); */
 308
 309   switch (filter->algorithm) {
 310
 311     case GST_PITCH_ALGORITHM_FFT:
 312       {
 313         gint module = 0;
 314
 315         for (i = min_i; i < max_i; i++) {
 316           module = (filter->spectrum[i].r * filter->spectrum[i].r);
 317           module += (filter->spectrum[i].i * filter->spectrum[i].i);
 318
 319           if (module > 0)
 320             GST_LOG_OBJECT (filter, "module[%d] = %d", i, module);
 321
 322           /* find strongest peak */
 323           if (module > frequency_module) {
 324             frequency_module = module;
 325             frequency = i;
 326           }
 327         }
 328       }
 329       break;
 330
 331     case GST_PITCH_ALGORITHM_HPS:
 332       {
 333         gint prev_frequency = 0;
 334         gint j, t;
 335
 336         for (i = min_i; i < RATE; i++) {
 337           filter->module[i] = (filter->spectrum[i].r * filter->spectrum[i].r);
 338           filter->module[i] += (filter->spectrum[i].i * filter->spectrum[i].i);
 339
 340           if (filter->module[i] > 0)
 341             GST_LOG_OBJECT (filter, "module[%d] = %d", i, filter->module[i]);
 342
 343         }
 344         /* Harmonic Product Spectrum algorithm */
 345 #define MAX_DS_FACTOR (6)
 346         for (i = min_i; (i <= max_i) && (i < RATE); i++) {
 347           for (j = 2; j <= MAX_DS_FACTOR; j++) {
 348             t = i * j;
 349             if (t > RATE)
 350               break;
 351
 352             /* this is not part of the HPS but it seems
 353              * there are lots of zeroes in the spectrum ...
 354              */
 355             if (filter->module[t] != 0)
 356               filter->module[i] *= filter->module[t];
 357           }
 358
 359           /* find strongest peak */
 360           if (filter->module[i] > frequency_module) {
 361             prev_frequency = frequency;
 362             frequency_module = filter->module[i];
 363             frequency = i;
 364           }
 365         }
 366
 367         /* try to correct octave error */
 368         if (frequency != 0 && prev_frequency != 0) {
 369           float ratio = (float) frequency / (float) prev_frequency;
 370           if (ratio >= 1.9 && ratio < 2.1 && (float) filter->module[prev_frequency] >= 0.2 * (float) frequency_module ) {
 371             g_debug("Chose freq %d[%d] over %d[%d]\n", prev_frequency, filter->module[prev_frequency], frequency, filter->module[frequency]);
 372             frequency = prev_frequency;
 373             frequency_module = filter->module[prev_frequency];
 374           }
 375         }
 376       }
 377       break;
 378     default:
 379       break;
 380   }
 381
 382   /*
 383   g_debug("freq %d[%d]\n", frequency, frequency_module);
 384   */
 385   GST_DEBUG_OBJECT (filter, "preparing message, frequency = %d ", frequency);
 386
 387   s = gst_structure_new ("pitch", "frequency", G_TYPE_INT, frequency, NULL);
 388
 389   return gst_message_new_element (GST_OBJECT (filter), s);
 390 }
 391
 392 /* GstBaseTransform vmethod implementations */
 393
 394 /* this function does the actual processing
 395  */
 396 static GstFlowReturn
 397 gst_pitch_transform_ip (GstBaseTransform * trans, GstBuffer * in)
 398 {
 399   GstPitch *filter = GST_PITCH (trans);
 400   gint16 *samples;
 401   gint i;
 402   guint avail;
 403
 404   GST_DEBUG_OBJECT (filter, "transform : %ld bytes", GST_BUFFER_SIZE (in));
 405   gst_adapter_push (filter->adapter, gst_buffer_ref (in));
 406
 407   /* required number of bytes */
 408   avail = gst_adapter_available (filter->adapter);
 409   GST_DEBUG_OBJECT (filter, "avail: %d wanted: %d", avail, WANTED);
 410
 411   if (avail > WANTED) {
 412
 413     /* copy sample data in the complex vector */
 414     samples = (gint16 *) gst_adapter_peek (filter->adapter, WANTED);
 415
 416     for (i = 0; i < RATE; i++) {
 417       filter->signal[i].r = (kiss_fft_scalar) (samples[i]);
 418     }
 419
 420     /* flush half second of data to implement sliding window */
 421     gst_adapter_flush (filter->adapter, WANTED >> 1);
 422
 423     GST_DEBUG ("perform fft");
 424     kiss_fft (filter->fft_cfg, filter->signal, filter->spectrum);
 425
 426     if (filter->message) {
 427       GstMessage *m = gst_pitch_message_new (filter);
 428       gst_element_post_message (GST_ELEMENT (filter), m);
 429     }
 430   }
 431
 432   return GST_FLOW_OK;
 433 }
 434
 435
 436 /* entry point to initialize the plug-in
 437  * initialize the plug-in itself
 438  * register the element factories and pad templates
 439  * register the features
 440  *
 441  * exchange the string 'plugin' with your elemnt name
 442  */
 443 /* static */ gboolean
 444 plugin_pitch_init (GstPlugin * plugin)
 445 {
 446   return gst_element_register (plugin, "pitch", GST_RANK_NONE, GST_TYPE_PITCH);
 447 }
 448
 449 /* this is the structure that gstreamer looks for to register plugins
 450  *
 451  * exchange the strings 'plugin' and 'Template plugin' with you plugin name and
 452  * description
 453  */
 454 #if 0
 455 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 456     GST_VERSION_MINOR,
 457     "pitch",
 458     "Run an FFT on the audio signal, output fundamental frequency",
 459     plugin_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")
 460 #endif