2 * This file is part of DisOrder
3 * Copyright (C) 2013 Mark Wooding
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 /** @file server/gstdecode.c
19 * @brief Decode compressed audio files, and apply ReplayGain.
22 #include "disorder-server.h"
24 #include "speaker-protocol.h"
26 /* Ugh. It turns out that libxml tries to define a function called
27 * `attribute', and it's included by GStreamer for some unimaginable reason.
28 * So undefine it here. We'll want GCC attributes for special effects, but
29 * can take care of ourselves.
35 #include <gst/app/gstappsink.h>
36 #include <gst/audio/audio.h>
38 /* The only applications we have for `attribute' is declaring function
39 * arguments as being unused, because we have a lot of callback functions
40 * which are meant to comply with an externally defined interface; and
41 * marking `help' as not returning.
44 # define NORETURN __attribute__((noreturn))
45 # define UNUSED __attribute__((unused))
48 #define END ((void *)0)
49 #define N(v) (sizeof(v)/sizeof(*(v)))
52 static const char *file;
53 static GstAppSink *appsink;
54 static GstElement *pipeline;
55 static GMainLoop *loop;
56 static unsigned flags = 0;
59 #define MODES(_) _("off", OFF) _("track", TRACK) _("album", ALBUM)
61 #define DEFENUM(name, tag) tag,
66 static const char *const modes[] = {
67 #define DEFNAME(name, tag) name,
73 static const char *const dithers[] = {
74 "none", "rpdf", "tpdf", "tpdf-hf", 0
77 static const char *const shapes[] = {
78 "none", "error-feedback", "simple", "medium", "high", 0
81 static int dither = -1;
82 static int mode = ALBUM;
83 static int quality = -1;
84 static int shape = -1;
85 static gdouble fallback = 0.0;
87 static struct stream_header hdr;
89 /* Report the pads of an element ELT, as iterated by IT; WHAT is an adjective
90 * phrase describing the pads for use in the output.
92 static void report_element_pads(const char *what, GstElement *elt,
96 #ifdef HAVE_GSTREAMER_0_10
105 #ifdef HAVE_GSTREAMER_0_10
106 switch(gst_iterator_next(it, &pad)) {
108 switch(gst_iterator_next(it, &gv)) {
110 case GST_ITERATOR_DONE:
112 case GST_ITERATOR_OK:
113 #ifdef HAVE_GSTREAMER_0_10
114 cs = gst_caps_to_string(GST_PAD_CAPS(pad));
116 assert(G_VALUE_HOLDS(&gv, GST_TYPE_PAD));
117 pad = g_value_get_object(&gv);
118 caps = gst_pad_query_caps(pad, 0);
119 cs = gst_caps_to_string(caps);
120 gst_caps_unref(caps);
122 disorder_error(0, " `%s' %s pad: %s", GST_OBJECT_NAME(elt), what, cs);
124 gst_object_unref(pad);
126 case GST_ITERATOR_RESYNC:
127 gst_iterator_resync(it);
129 case GST_ITERATOR_ERROR:
130 disorder_error(0, "<failed to enumerate `%s' %s pads>",
131 GST_OBJECT_NAME(elt), what);
137 gst_iterator_free(it);
140 /* Link together two elements; fail with an approximately useful error
141 * message if it didn't work.
143 static void link_elements(GstElement *left, GstElement *right)
145 /* Try to link things together. */
146 if(gst_element_link(left, right)) return;
148 /* If this didn't work, it's probably for some really hairy reason, so
149 * provide a bunch of debugging information.
151 disorder_error(0, "failed to link GStreamer elements `%s' and `%s'",
152 GST_OBJECT_NAME(left), GST_OBJECT_NAME(right));
153 report_element_pads("source", left, gst_element_iterate_src_pads(left));
154 report_element_pads("dest", right, gst_element_iterate_sink_pads(right));
155 disorder_fatal(0, "can't decode `%s'", file);
158 /* The `decoderbin' element (DECODE) has deigned to announce a new PAD.
159 * Maybe we should attach the tag end of our pipeline (starting with the
162 static void decoder_pad_arrived(GstElement *decode, GstPad *pad, gpointer u)
164 GstElement *tail = u;
165 #ifdef HAVE_GSTREAMER_0_10
166 GstCaps *caps = gst_pad_get_caps(pad);
168 GstCaps *caps = gst_pad_get_current_caps(pad);
174 /* The input file could be more or less anything, so this could be any kind
175 * of pad. We're only interested if it's audio, so let's go check.
177 for(i = 0, n = gst_caps_get_size(caps); i < n; i++) {
178 s = gst_caps_get_structure(caps, i);
179 name = gst_structure_get_name(s);
180 #ifdef HAVE_GSTREAMER_0_10
181 if(strncmp(name, "audio/x-raw-", 12) == 0)
183 if(strcmp(name, "audio/x-raw") == 0)
190 /* Yes, it's audio. Link the two elements together. */
191 link_elements(decode, tail);
193 /* If requested using the environemnt variable `GST_DEBUG_DUMP_DOT_DIR',
194 * write a dump of the now-completed pipeline.
196 GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(pipeline),
197 GST_DEBUG_GRAPH_SHOW_ALL,
198 "disorder-gstdecode");
201 gst_caps_unref(caps);
204 /* Prepare the GStreamer pipeline, ready to decode the given FILE. This sets
205 * up the variables `appsink' and `pipeline'.
207 static void prepare_pipeline(void)
209 GstElement *source = gst_element_factory_make("filesrc", "file");
210 GstElement *decode = gst_element_factory_make("decodebin", "decode");
211 GstElement *resample = gst_element_factory_make("audioresample",
213 GstElement *convert = gst_element_factory_make("audioconvert", "convert");
214 GstElement *sink = gst_element_factory_make("appsink", "sink");
215 GstElement *tail = sink;
218 const struct stream_header *fmt = &config->sample_format;
220 if(!source || !decode || !resample || !convert || !sink)
221 disorder_fatal(0, "failed to create GStreamer elements: "
222 "need base and good plugins");
224 #ifndef HAVE_GSTREAMER_0_10
225 static const struct fmttab {
230 { "S8", 8, ENDIAN_BIG },
231 { "S8", 8, ENDIAN_LITTLE },
232 { "S16BE", 16, ENDIAN_BIG },
233 { "S16LE", 16, ENDIAN_LITTLE },
236 const struct fmttab *ft;
239 /* Set up the global variables. */
240 pipeline = gst_pipeline_new("pipe");
241 appsink = GST_APP_SINK(sink);
243 /* Configure the various simple elements. */
244 g_object_set(source, "location", file, END);
245 g_object_set(sink, "sync", FALSE, END);
247 /* Configure the resampler and converter. Leave things as their defaults
248 * if the user hasn't made an explicit request.
250 if(quality >= 0) g_object_set(resample, "quality", quality, END);
251 if(dither >= 0) g_object_set(convert, "dithering", dither, END);
252 if(shape >= 0) g_object_set(convert, "noise-shaping", shape, END);
254 /* Set up the sink's capabilities from the configuration. */
255 #ifdef HAVE_GSTREAMER_0_10
256 caps = gst_caps_new_simple("audio/x-raw-int",
257 "width", G_TYPE_INT, fmt->bits,
258 "depth", G_TYPE_INT, fmt->bits,
259 "channels", G_TYPE_INT, fmt->channels,
260 "signed", G_TYPE_BOOLEAN, TRUE,
261 "rate", G_TYPE_INT, fmt->rate,
262 "endianness", G_TYPE_INT,
263 fmt->endian == ENDIAN_BIG ?
264 G_BIG_ENDIAN : G_LITTLE_ENDIAN,
267 for (ft = fmttab; ft->fmt; ft++)
268 if (ft->bits == fmt->bits && ft->endian == fmt->endian) break;
270 disorder_fatal(0, "unsupported sample format: bits=%"PRIu32", endian=%u",
271 fmt->bits, fmt->endian);
273 caps = gst_caps_new_simple("audio/x-raw",
274 "format", G_TYPE_STRING, ft->fmt,
275 "channels", G_TYPE_INT, fmt->channels,
276 "rate", G_TYPE_INT, fmt->rate,
279 gst_app_sink_set_caps(appsink, caps);
280 gst_caps_unref(caps);
282 /* Add the various elements into the pipeline. We'll stitch them together
283 * in pieces, because the pipeline is somewhat dynamic.
285 gst_bin_add_many(GST_BIN(pipeline),
287 resample, convert, sink, END);
289 /* Link audio conversion stages onto the front. The rest of DisOrder
290 * doesn't handle much of the full panoply of exciting audio formats.
292 link_elements(convert, tail); tail = convert;
293 link_elements(resample, tail); tail = resample;
295 /* If we're meant to do ReplayGain then insert it into the pipeline before
299 gain = gst_element_factory_make("rgvolume", "gain");
301 disorder_fatal(0, "failed to create GStreamer elements: "
302 "need base and good plugins");
304 "album-mode", mode == ALBUM,
305 "fallback-gain", fallback,
307 gst_bin_add(GST_BIN(pipeline), gain);
308 link_elements(gain, tail); tail = gain;
311 /* Link the source and the decoder together. The `decodebin' is annoying
312 * and doesn't have any source pads yet, so the best we can do is make two
313 * halves of the chain, and add a hook to stitch them together later.
315 link_elements(source, decode);
316 g_signal_connect(decode, "pad-added",
317 G_CALLBACK(decoder_pad_arrived), tail);
320 /* Respond to a message from the BUS. The only thing we need worry about
321 * here is errors from the pipeline.
323 static void bus_message(GstBus UNUSED *bus, GstMessage *msg,
326 switch(GST_MESSAGE_TYPE(msg)) {
327 case GST_MESSAGE_ERROR:
328 disorder_fatal(0, "%s",
329 gst_structure_get_string(gst_message_get_structure(msg),
336 /* End of stream. Stop polling the main loop. */
337 static void cb_eos(GstAppSink UNUSED *sink, gpointer UNUSED u)
338 { g_main_loop_quit(loop); }
340 /* Preroll buffers are prepared when the pipeline moves to the `paused'
341 * state, so that they're ready for immediate playback. Conveniently, they
342 * also carry format information, which is what we want here. Stash the
343 * sample format information in the `stream_header' structure ready for
344 * actual buffers of interesting data.
346 static GstFlowReturn cb_preroll(GstAppSink *sink, gpointer UNUSED u)
348 #ifdef HAVE_GSTREAMER_0_10
349 GstBuffer *buf = gst_app_sink_pull_preroll(sink);
350 GstCaps *caps = GST_BUFFER_CAPS(buf);
352 GstSample *samp = gst_app_sink_pull_preroll(sink);
353 GstCaps *caps = gst_sample_get_caps(samp);
356 #ifdef HAVE_GST_AUDIO_INFO_FROM_CAPS
358 /* Parse the audio format information out of the caps. There's a handy
359 * function to do this in later versions of gst-plugins-base, so use that
360 * if it's available. Once we no longer care about supporting such old
361 * versions we can delete the version which does the job the hard way.
366 if(!gst_audio_info_from_caps(&ai, caps))
367 disorder_fatal(0, "can't decode `%s': failed to parse audio info", file);
369 hdr.channels = ai.channels;
370 hdr.bits = ai.finfo->width;
371 hdr.endian = ai.finfo->endianness == G_BIG_ENDIAN ?
372 ENDIAN_BIG : ENDIAN_LITTLE;
378 gint rate, channels, bits, endian;
381 /* Make sure that the caps is basically the right shape. */
382 if(!GST_CAPS_IS_SIMPLE(caps)) disorder_fatal(0, "expected simple caps");
383 s = gst_caps_get_structure(caps, 0);
384 ty = gst_structure_get_name(s);
385 if(strcmp(ty, "audio/x-raw-int") != 0)
386 disorder_fatal(0, "unexpected content type `%s'", ty);
388 /* Extract fields from the structure. */
389 if(!gst_structure_get(s,
390 "rate", G_TYPE_INT, &rate,
391 "channels", G_TYPE_INT, &channels,
392 "width", G_TYPE_INT, &bits,
393 "endianness", G_TYPE_INT, &endian,
394 "signed", G_TYPE_BOOLEAN, &signedp,
396 disorder_fatal(0, "can't decode `%s': failed to parse audio caps", file);
397 hdr.rate = rate; hdr.channels = channels; hdr.bits = bits;
398 hdr.endian = endian == G_BIG_ENDIAN ? ENDIAN_BIG : ENDIAN_LITTLE;
402 #ifdef HAVE_GSTREAMER_0_10
403 gst_buffer_unref(buf);
405 gst_sample_unref(samp);
410 /* A new buffer of sample data has arrived, so we should pass it on with
411 * appropriate framing.
413 static GstFlowReturn cb_buffer(GstAppSink *sink, gpointer UNUSED u)
415 #ifdef HAVE_GSTREAMER_0_10
416 GstBuffer *buf = gst_app_sink_pull_buffer(sink);
418 GstSample *samp = gst_app_sink_pull_sample(sink);
419 GstBuffer *buf = gst_sample_get_buffer(samp);
425 /* Make sure we actually have a grip on the sample format here. */
426 if(!hdr.rate) disorder_fatal(0, "format unset");
428 /* Write out a frame of audio data. */
429 #ifdef HAVE_GSTREAMER_0_10
430 hdr.nbytes = GST_BUFFER_SIZE(buf);
431 if((!(flags&f_stream) && fwrite(&hdr, sizeof(hdr), 1, fp) != 1) ||
432 fwrite(GST_BUFFER_DATA(buf), 1, hdr.nbytes, fp) != hdr.nbytes)
433 disorder_fatal(errno, "output");
435 for(i = 0, n = gst_buffer_n_memory(buf); i < n; i++) {
436 mem = gst_buffer_peek_memory(buf, i);
437 if(!gst_memory_map(mem, &map, GST_MAP_READ))
438 disorder_fatal(0, "failed to map sample buffer");
439 hdr.nbytes = map.size;
440 if((!(flags&f_stream) && fwrite(&hdr, sizeof(hdr), 1, fp) != 1) ||
441 fwrite(map.data, 1, map.size, fp) != map.size)
442 disorder_fatal(errno, "output");
443 gst_memory_unmap(mem, &map);
447 /* And we're done. */
448 #ifdef HAVE_GSTREAMER_0_10
449 gst_buffer_unref(buf);
451 gst_sample_unref(samp);
456 static GstAppSinkCallbacks callbacks = {
458 .new_preroll = cb_preroll,
459 #ifdef HAVE_GSTREAMER_0_10
460 .new_buffer = cb_buffer
462 .new_sample = cb_buffer
466 /* Decode the audio file. We're already set up for everything. */
467 static void decode(void)
469 GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
471 /* Set up the message bus and main loop. */
472 gst_bus_add_signal_watch(bus);
473 loop = g_main_loop_new(0, FALSE);
474 g_signal_connect(bus, "message", G_CALLBACK(bus_message), 0);
476 /* Tell the sink to call us when interesting things happen. */
477 gst_app_sink_set_max_buffers(appsink, 16);
478 gst_app_sink_set_drop(appsink, FALSE);
479 gst_app_sink_set_callbacks(appsink, &callbacks, 0, 0);
481 /* Set the ball rolling. */
482 gst_element_set_state(pipeline, GST_STATE_PLAYING);
484 /* And wait for the miracle to come. */
485 g_main_loop_run(loop);
487 /* Shut down the pipeline. This isn't strictly necessary, since we're
488 * about to exit very soon, but it's kind of polite.
490 gst_element_set_state(pipeline, GST_STATE_NULL);
493 static int getenum(const char *what, const char *s, const char *const *tags)
497 for(i = 0; tags[i]; i++)
498 if(strcmp(s, tags[i]) == 0) return i;
499 disorder_fatal(0, "unknown %s `%s'", what, s);
502 static double getfloat(const char *what, const char *s)
509 if(*q || errno) disorder_fatal(0, "invalid %s `%s'", what, s);
513 static int getint(const char *what, const char *s, int min, int max)
519 i = strtol(s, &q, 10);
520 if(*q || errno || min > i || i > max)
521 disorder_fatal(0, "invalid %s `%s'", what, s);
525 static const struct option options[] = {
526 { "help", no_argument, 0, 'h' },
527 { "version", no_argument, 0, 'V' },
528 { "config", required_argument, 0, 'c' },
529 { "dither", required_argument, 0, 'd' },
530 { "fallback-gain", required_argument, 0, 'f' },
531 { "noise-shape", required_argument, 0, 'n' },
532 { "quality", required_argument, 0, 'q' },
533 { "replay-gain", required_argument, 0, 'r' },
534 { "stream", no_argument, 0, 's' },
538 static void NORETURN help(void)
541 " disorder-gstdecode [OPTIONS] PATH\n"
543 " --help, -h Display usage message\n"
544 " --version, -V Display version number\n"
545 " --config PATH, -c PATH Set configuration file\n"
546 " --dither TYPE, -d TYPE TYPE is `none', `rpdf', `tpdf', or "
548 " --fallback-gain DB, -f DB For tracks without ReplayGain data\n"
549 " --noise-shape TYPE, -n TYPE TYPE is `none', `error-feedback',\n"
550 " `simple', `medium' or `high'\n"
551 " --quality QUAL, -q QUAL Resampling quality: 0 poor, 10 good\n"
552 " --replay-gain MODE, -r MODE MODE is `off', `track' or `album'\n"
553 " --stream, -s Output raw samples, without framing\n"
555 "Alternative audio decoder for DisOrder. Only intended to be\n"
556 "used by speaker process, not for normal users.\n");
562 int main(int argc, char *argv[])
569 if(!setlocale(LC_CTYPE, "")) disorder_fatal(errno, "calling setlocale");
571 /* Parse command line. */
572 while((n = getopt_long(argc, argv, "hVc:d:f:n:q:r:s", options, 0)) >= 0) {
575 case 'V': version("disorder-gstdecode");
576 case 'c': configfile = optarg; break;
577 case 'd': dither = getenum("dither type", optarg, dithers); break;
578 case 'f': fallback = getfloat("fallback gain", optarg); break;
579 case 'n': shape = getenum("noise-shaping type", optarg, shapes); break;
580 case 'q': quality = getint("resample quality", optarg, 0, 10); break;
581 case 'r': mode = getenum("ReplayGain mode", optarg, modes); break;
582 case 's': flags |= f_stream; break;
583 default: disorder_fatal(0, "invalid option");
586 if(optind >= argc) disorder_fatal(0, "missing filename");
587 file = argv[optind++];
588 if(optind < argc) disorder_fatal(0, "excess arguments");
589 if(config_read(1, 0)) disorder_fatal(0, "cannot read configuration");
591 /* Set up the GStreamer machinery. */
595 /* Set up the output file. */
596 if((e = getenv("DISORDER_RAW_FD")) != 0) {
597 if((fp = fdopen(atoi(e), "wb")) == 0) disorder_fatal(errno, "fdopen");
604 /* And now we're done. */