code.delx.au - pulseaudio/blob - polyp/module-sine.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <assert.h>
  28 #include <math.h>
  29
  30 #include "sink-input.h"
  31 #include "module.h"
  32 #include "modargs.h"
  33 #include "xmalloc.h"
  34 #include "namereg.h"
  35 #include "log.h"
  36
  37 PA_MODULE_AUTHOR("Lennart Poettering")
  38 PA_MODULE_DESCRIPTION("Sine wave generator")
  39 PA_MODULE_USAGE("sink=<sink to connect to> frequency=<frequency in Hz>")
  40 PA_MODULE_VERSION(PACKAGE_VERSION)
  41
  42 struct userdata {
  43     struct pa_core *core;
  44     struct pa_sink_input *sink_input;
  45     struct pa_memblock *memblock;
  46     size_t peek_index;
  47 };
  48
  49 static const char* const valid_modargs[] = {
  50     "sink",
  51     "frequency",
  52     NULL,
  53 };
  54
  55 static int sink_input_peek(struct pa_sink_input *i, struct pa_memchunk *chunk) {
  56     struct userdata *u;
  57     assert(i && chunk && i->userdata);
  58     u = i->userdata;
  59
  60     chunk->memblock = pa_memblock_ref(u->memblock);
  61     chunk->index = u->peek_index;
  62     chunk->length = u->memblock->length - u->peek_index;
  63     return 0;
  64 }
  65
  66 static void sink_input_drop(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
  67     struct userdata *u;
  68     assert(i && chunk && length && i->userdata);
  69     u = i->userdata;
  70
  71     assert(chunk->memblock == u->memblock && length <= u->memblock->length-u->peek_index);
  72
  73     u->peek_index += length;
  74
  75     if (u->peek_index >= u->memblock->length)
  76         u->peek_index = 0;
  77 }
  78
  79 static void sink_input_kill(struct pa_sink_input *i) {
  80     struct userdata *u;
  81     assert(i && i->userdata);
  82     u = i->userdata;
  83
  84     pa_sink_input_free(u->sink_input);
  85     u->sink_input = NULL;
  86 }
  87
  88 static void calc_sine(float *f, size_t l, float freq) {
  89     size_t i;
  90
  91     l /= sizeof(float);
  92
  93     for (i = 0; i < l; i++)
  94         f[i] = (float) sin((double) i/l*M_PI*2*freq)/2;
  95 }
  96
  97 int pa__init(struct pa_core *c, struct pa_module*m) {
  98     struct pa_modargs *ma = NULL;
  99     struct userdata *u;
 100     struct pa_sink *sink;
 101     const char *sink_name;
 102     struct pa_sample_spec ss;
 103     uint32_t frequency;
 104     char t[256];
 105
 106     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 107         pa_log(__FILE__": Failed to parse module arguments\n");
 108         goto fail;
 109     }
 110
 111     m->userdata = u = pa_xmalloc(sizeof(struct userdata));
 112     u->core = c;
 113     u->sink_input = NULL;
 114     u->memblock = NULL;
 115
 116     sink_name = pa_modargs_get_value(ma, "sink", NULL);
 117
 118     if (!(sink = pa_namereg_get(c, sink_name, PA_NAMEREG_SINK, 1))) {
 119         pa_log(__FILE__": No such sink.\n");
 120         goto fail;
 121     }
 122
 123     ss.format = PA_SAMPLE_FLOAT32;
 124     ss.rate = sink->sample_spec.rate;
 125     ss.channels = 1;
 126
 127     frequency = 440;
 128     if (pa_modargs_get_value_u32(ma, "frequency", &frequency) < 0 || frequency < 1 || frequency > ss.rate/2) {
 129         pa_log(__FILE__": Invalid frequency specification\n");
 130         goto fail;
 131     }
 132
 133     u->memblock = pa_memblock_new(pa_bytes_per_second(&ss), c->memblock_stat);
 134     calc_sine(u->memblock->data, u->memblock->length, frequency);
 135
 136     snprintf(t, sizeof(t), "Sine Generator at %u Hz", frequency);
 137     if (!(u->sink_input = pa_sink_input_new(sink, t, &ss)))
 138         goto fail;
 139
 140     u->sink_input->peek = sink_input_peek;
 141     u->sink_input->drop = sink_input_drop;
 142     u->sink_input->kill = sink_input_kill;
 143     u->sink_input->userdata = u;
 144     u->sink_input->owner = m;
 145
 146     u->peek_index = 0;
 147
 148     pa_modargs_free(ma);
 149     return 0;
 150
 151 fail:
 152     if (ma)
 153         pa_modargs_free(ma);
 154
 155     pa__done(c, m);
 156     return -1;
 157 }
 158
 159 void pa__done(struct pa_core *c, struct pa_module*m) {
 160     struct userdata *u = m->userdata;
 161     assert(c && m);
 162
 163     if (!u)
 164         return;
 165
 166     if (u->sink_input)
 167         pa_sink_input_free(u->sink_input);
 168     if (u->memblock)
 169         pa_memblock_unref(u->memblock);
 170     pa_xfree(u);
 171 }
 172