src/module-pipe-sink.c

   1 #include <stdlib.h>
   2 #include <sys/stat.h>
   3 #include <stdio.h>
   4 #include <assert.h>
   5 #include <errno.h>
   6 #include <string.h>
   7 #include <fcntl.h>
   8 #include <unistd.h>
   9 #include <limits.h>
  10
  11 #include "iochannel.h"
  12 #include "sink.h"
  13 #include "module.h"
  14 #include "util.h"
  15
  16 struct userdata {
  17     char *filename;
  18
  19     struct pa_sink *sink;
  20     struct pa_iochannel *io;
  21     struct pa_core *core;
  22     void *mainloop_source;
  23     struct pa_mainloop_api *mainloop;
  24
  25     struct pa_memchunk memchunk;
  26 };
  27
  28 static void do_write(struct userdata *u) {
  29     ssize_t r;
  30     assert(u);
  31
  32     u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 0);
  33
  34     if (!pa_iochannel_is_writable(u->io))
  35         return;
  36
  37     if (!u->memchunk.length)
  38         if (pa_sink_render(u->sink, PIPE_BUF, &u->memchunk) < 0)
  39             return;
  40
  41     assert(u->memchunk.memblock && u->memchunk.length);
  42
  43     if ((r = pa_iochannel_write(u->io, u->memchunk.memblock->data + u->memchunk.index, u->memchunk.length)) < 0) {
  44         fprintf(stderr, "write() failed: %s\n", strerror(errno));
  45         return;
  46     }
  47
  48     u->memchunk.index += r;
  49     u->memchunk.length -= r;
  50
  51     if (u->memchunk.length <= 0) {
  52         pa_memblock_unref(u->memchunk.memblock);
  53         u->memchunk.memblock = NULL;
  54     }
  55 }
  56
  57 static void notify_cb(struct pa_sink*s) {
  58     struct userdata *u = s->userdata;
  59     assert(s && u);
  60
  61     if (pa_iochannel_is_writable(u->io))
  62         u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 1);
  63 }
  64
  65 static void fixed_callback(struct pa_mainloop_api *m, void *id, void *userdata) {
  66     struct userdata *u = userdata;
  67     assert(u);
  68     do_write(u);
  69 }
  70
  71 static void io_callback(struct pa_iochannel *io, void*userdata) {
  72     struct userdata *u = userdata;
  73     assert(u);
  74     do_write(u);
  75 }
  76
  77 int pa_module_init(struct pa_core *c, struct pa_module*m) {
  78     struct userdata *u = NULL;
  79     struct stat st;
  80     char *p;
  81     int fd = -1;
  82     static const struct pa_sample_spec ss = {
  83         .format = PA_SAMPLE_S16NE,
  84         .rate = 44100,
  85         .channels = 2,
  86     };
  87     assert(c && m);
  88
  89     mkfifo((p = m->argument ? m->argument : "/tmp/musicfifo"), 0777);
  90
  91     if ((fd = open(p, O_RDWR)) < 0) {
  92         fprintf(stderr, "open('%s'): %s\n", p, strerror(errno));
  93         goto fail;
  94     }
  95
  96     if (fstat(fd, &st) < 0) {
  97         fprintf(stderr, "fstat('%s'): %s\n", p, strerror(errno));
  98         goto fail;
  99     }
 100
 101     if (!S_ISFIFO(st.st_mode)) {
 102         fprintf(stderr, "'%s' is not a FIFO\n", p);
 103         goto fail;
 104     }
 105
 106
 107     u = malloc(sizeof(struct userdata));
 108     assert(u);
 109
 110     u->filename = strdup(p);
 111     assert(u->filename);
 112     u->core = c;
 113     u->sink = pa_sink_new(c, "fifo", 0, &ss);
 114     assert(u->sink);
 115     u->sink->notify = notify_cb;
 116     u->sink->userdata = u;
 117     pa_sink_set_owner(u->sink, m);
 118     u->sink->description = pa_sprintf_malloc("Unix FIFO sink '%s'", p);
 119     assert(u->sink->description);
 120
 121     u->io = pa_iochannel_new(c->mainloop, -1, fd);
 122     assert(u->io);
 123     pa_iochannel_set_callback(u->io, io_callback, u);
 124
 125     u->memchunk.memblock = NULL;
 126     u->memchunk.length = 0;
 127
 128     u->mainloop = c->mainloop;
 129     u->mainloop_source = u->mainloop->source_fixed(u->mainloop, fixed_callback, u);
 130     assert(u->mainloop_source);
 131     u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 0);
 132
 133     m->userdata = u;
 134
 135     return 0;
 136
 137 fail:
 138     if (fd >= 0)
 139         close(fd);
 140
 141     return -1;
 142 }
 143
 144 void pa_module_done(struct pa_core *c, struct pa_module*m) {
 145     struct userdata *u;
 146     assert(c && m);
 147
 148     u = m->userdata;
 149     assert(u);
 150
 151     if (u->memchunk.memblock)
 152         pa_memblock_unref(u->memchunk.memblock);
 153
 154     pa_sink_free(u->sink);
 155     pa_iochannel_free(u->io);
 156     u->mainloop->cancel_fixed(u->mainloop, u->mainloop_source);
 157
 158     assert(u->filename);
 159     unlink(u->filename);
 160     free(u->filename);
 161
 162     free(u);
 163 }