mixer.c

   1 #include "modules.h"
   2 #include "graph.h"
   3 #include "errors.h"
   4 #include "assert.h"
   5 #include "stdio.h"
   6
   7 ///// Simple additive mixer /////
   8 ///// TODO: handle different input formats /////
   9
  10 struct mixer {
  11     bool format_is_set;
  12     struct aformat af;
  13     struct graphpin *out_pin;
  14     int n_inputs;
  15 };
  16
  17 static bool is_acceptable_input_format(struct graphnode *node, struct graphpin *pin, const struct aformat *af)
  18 {
  19     struct mixer *m = node->extra;
  20     assert(pin != m->out_pin);
  21     if (m->format_is_set){
  22         return af->media == m->af.media
  23             && af->srate == m->af.srate
  24             && af->channels == m->af.channels;
  25     } else {
  26         return true;
  27     }
  28 }
  29
  30 static err_t get_output_format(struct graphnode *node, struct graphpin *pin, struct aformat *af)
  31 {
  32     struct mixer *m = node->extra;
  33     assert(pin == m->out_pin);
  34
  35     if (m->format_is_set){
  36         *af = m->af;
  37         return EOK;
  38     } else {
  39         return make_error(ECANNOT_GUESS_FORMAT, node, "mixer module is not yet bound to a format");
  40     }
  41 }
  42
  43 static err_t another_in_pin(struct graphnode *node, struct mixer *m)
  44 {
  45     // create a new input pin
  46     struct graphpin *new_pin;
  47     err_t err;
  48     char *new_name = NULL;
  49
  50     err = graphnode_add_pin(node, &new_pin);
  51     if (err != EOK){
  52         return err;
  53     }
  54     asprintf(&new_name, "in%d", m->n_inputs);
  55     new_pin->name = new_name;
  56     new_pin->dir = DIR_IN;
  57     ++m->n_inputs;
  58     return EOK;
  59 }
  60
  61 static err_t set_buffer(struct graphnode *node, struct graphpin *pin, struct buffer *buf)
  62 {
  63     struct mixer *m = node->extra;
  64     if (m->format_is_set){
  65         if (buf->format.media == m->af.media
  66           && buf->format.srate == m->af.srate
  67           && buf->format.channels == m->af.channels){
  68             return another_in_pin(node, m);
  69         } else {
  70             return make_error(EBAD_FORMAT, node, "mixer module is being connected to a bad media format");
  71         }
  72     } else {
  73         m->af = buf->format;
  74         m->format_is_set = true;
  75         return another_in_pin(node, m);
  76     }
  77 }
  78
  79 static size_t longest_in_buf_len(struct graphnode *restrict node)
  80 {
  81     struct graphpin *in_pin;
  82     size_t sz = 0;
  83
  84     for (in_pin=node->pins; in_pin; in_pin=in_pin->next){
  85         if (in_pin->dir != DIR_IN || !in_pin->edge){
  86             continue;
  87         }
  88         if (in_pin->edge->buf.n_samples > sz){
  89             sz = in_pin->edge->buf.n_samples;
  90         }
  91     }
  92     return sz;
  93 }
  94
  95 static err_t run(struct graphnode *node)
  96 {
  97 #define DO_MIX(T) { \
  98     T *restrict s_ptr, *restrict d_ptr; \
  99     register int i; \
 100     /* clear the output buffer */ \
 101     d_ptr = d_buf->data; \
 102     for (i=sz; i; --i){ \
 103         *d_ptr++ = 0; \
 104     } \
 105     \
 106     for (in_pin=node->pins; in_pin; in_pin=in_pin->next){ \
 107         if (in_pin->dir != DIR_IN || !in_pin->edge){ \
 108             continue; \
 109         } \
 110         s_ptr = in_pin->edge->buf.data; \
 111         d_ptr = d_buf->data; \
 112         for (i=sz; i; --i){ \
 113             /* Mix! */ \
 114             *d_ptr++ += *s_ptr++ / m->n_inputs; /* *boggle* */ \
 115         } \
 116     } \
 117     return EOK; }
 118
 119     struct mixer *restrict m = node->extra;
 120     struct graphpin *in_pin;
 121     struct buffer *restrict d_buf = &m->out_pin->edge->buf;
 122     size_t sz;
 123     err_t err;
 124
 125     sz = longest_in_buf_len(node);
 126     err = buffer_alloc(d_buf, sz);
 127     if (err != EOK){
 128         return err;
 129     }
 130
 131     sz *= m->out_pin->edge->buf.format.channels;
 132
 133     switch (m->out_pin->edge->buf.format.media){
 134         case MT_AUDIO_32F:
 135             DO_MIX(float)
 136         case MT_AUDIO_16I:
 137             DO_MIX(short)
 138         case MT_AUDIO_32I:
 139             DO_MIX(int)
 140     }
 141     return make_error(ENOTIMPL, NULL, "mixing these media types is not implemented");
 142 }
 143
 144 static const struct graphnode_functab functab = {
 145     is_acceptable_input_format,
 146     NULL,   // get_ideal_input_format
 147     get_output_format,
 148     set_buffer,
 149     run,
 150 };
 151
 152 err_t mixer_create(struct graphnode **node_out)
 153 {
 154     struct graphnode *node;
 155     struct mixer *m;
 156     struct graphpin *in_pin;
 157     err_t err;
 158
 159     err = graphnode_create(&node, &functab, sizeof *m);
 160     if (err != EOK){
 161         return err;
 162     }
 163     m = node->extra;
 164
 165     m->n_inputs = 1;
 166     m->format_is_set = false;
 167
 168     // create output pin
 169     err = graphnode_add_pin(node, &m->out_pin);
 170     if (err != EOK){
 171         return err;
 172     }
 173     m->out_pin->dir = DIR_OUT;
 174     m->out_pin->name = "out";
 175
 176     // create input pins
 177     err = graphnode_add_pin(node, &in_pin);
 178     if (err != EOK){
 179         return err;
 180     }
 181     in_pin->dir = DIR_IN;
 182     in_pin->name = "in0"; // how original
 183
 184     *node_out = node;
 185     return EOK;
 186 }