code.delx.au - pulseaudio/blob - 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
  15 struct userdata {
  16     char *filename;
  17
  18     struct sink *sink;
  19     struct iochannel *io;
  20     struct core *core;
  21     void *mainloop_source;
  22     struct pa_mainloop_api *mainloop;
  23
  24     struct memchunk memchunk;
  25 };
  26
  27 static void do_write(struct userdata *u) {
  28     ssize_t r;
  29     assert(u);
  30
  31     u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 0);
  32
  33     if (!iochannel_is_writable(u->io))
  34         return;
  35
  36     if (!u->memchunk.length)
  37         if (sink_render(u->sink, PIPE_BUF, &u->memchunk) < 0)
  38             return;
  39
  40     assert(u->memchunk.memblock && u->memchunk.length);
  41
  42     if ((r = iochannel_write(u->io, u->memchunk.memblock->data + u->memchunk.index, u->memchunk.length)) < 0) {
  43         fprintf(stderr, "write() failed: %s\n", strerror(errno));
  44         return;
  45     }
  46
  47     u->memchunk.index += r;
  48     u->memchunk.length -= r;
  49
  50     if (u->memchunk.length <= 0) {
  51         memblock_unref(u->memchunk.memblock);
  52         u->memchunk.memblock = NULL;
  53     }
  54 }
  55
  56 static void notify_cb(struct sink*s) {
  57     struct userdata *u = s->userdata;
  58     assert(s && u);
  59
  60     if (iochannel_is_writable(u->io))
  61         u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 1);
  62 }
  63
  64 static void fixed_callback(struct pa_mainloop_api *m, void *id, void *userdata) {
  65     struct userdata *u = userdata;
  66     assert(u);
  67     do_write(u);
  68 }
  69
  70 static void io_callback(struct iochannel *io, void*userdata) {
  71     struct userdata *u = userdata;
  72     assert(u);
  73     do_write(u);
  74 }
  75
  76 int module_init(struct core *c, struct module*m) {
  77     struct userdata *u = NULL;
  78     struct stat st;
  79     char *p;
  80     int fd = -1;
  81     static const struct pa_sample_spec ss = {
  82         .format = PA_SAMPLE_S16NE,
  83         .rate = 44100,
  84         .channels = 2,
  85     };
  86     assert(c && m);
  87
  88     mkfifo((p = m->argument ? m->argument : "/tmp/musicfifo"), 0777);
  89
  90     if ((fd = open(p, O_RDWR)) < 0) {
  91         fprintf(stderr, "open('%s'): %s\n", p, strerror(errno));
  92         goto fail;
  93     }
  94
  95     if (fstat(fd, &st) < 0) {
  96         fprintf(stderr, "fstat('%s'): %s\n", p, strerror(errno));
  97         goto fail;
  98     }
  99
 100     if (!S_ISFIFO(st.st_mode)) {
 101         fprintf(stderr, "'%s' is not a FIFO\n", p);
 102         goto fail;
 103     }
 104
 105
 106     u = malloc(sizeof(struct userdata));
 107     assert(u);
 108
 109     u->filename = strdup(p);
 110     assert(u->filename);
 111     u->core = c;
 112     u->sink = sink_new(c, "fifo", 0, &ss);
 113     assert(u->sink);
 114     u->sink->notify = notify_cb;
 115     u->sink->userdata = u;
 116
 117     u->io = iochannel_new(c->mainloop, -1, fd);
 118     assert(u->io);
 119     iochannel_set_callback(u->io, io_callback, u);
 120
 121     u->memchunk.memblock = NULL;
 122     u->memchunk.length = 0;
 123
 124     u->mainloop = c->mainloop;
 125     u->mainloop_source = u->mainloop->source_fixed(u->mainloop, fixed_callback, u);
 126     assert(u->mainloop_source);
 127     u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 0);
 128
 129     m->userdata = u;
 130
 131     return 0;
 132
 133 fail:
 134     if (fd >= 0)
 135         close(fd);
 136
 137     return -1;
 138 }
 139
 140 void module_done(struct core *c, struct module*m) {
 141     struct userdata *u;
 142     assert(c && m);
 143
 144     u = m->userdata;
 145     assert(u);
 146
 147     if (u->memchunk.memblock)
 148         memblock_unref(u->memchunk.memblock);
 149
 150     sink_free(u->sink);
 151     iochannel_free(u->io);
 152     u->mainloop->cancel_fixed(u->mainloop, u->mainloop_source);
 153
 154     assert(u->filename);
 155     unlink(u->filename);
 156     free(u->filename);
 157
 158     free(u);
 159 }