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