::\tSpecify ALSA params to open output device, b = buffer time in ms or size in bytes, p = period count or size in bytes, f sample format (16|24|24_3|32), m = use mmap (0|1)\n" +#endif +#if PORTAUDIO +#if OSX + " -a :\t\tSpecify Portaudio params to open output device, l = target latency in ms, r = allow OSX to resample (0|1)\n" +#else + " -a \t\tSpecify Portaudio params to open output device, l = target latency in ms\n" +#endif +#endif + " -a \t\tSpecify sample format (16|24|32) of output file when using -o - to output samples to stdout (interleaved little endian only)\n" + " -b :\tSpecify internal Stream and Output buffer sizes in Kbytes\n" + " -c ,\tRestrict codecs to those specified, otherwise load all available codecs; known codecs: " CODECS "\n" + " -C \t\tClose output device when idle after timeout seconds, default is to keep it open while player is 'on'\n" +#if !IR + " -d =\tSet logging level, logs: all|slimproto|stream|decode|output, level: info|debug|sdebug\n" +#else + " -d =\tSet logging level, logs: all|slimproto|stream|decode|output|ir, level: info|debug|sdebug\n" +#endif + " -e ,\tExplicitly exclude native support of one or more codecs; known codecs: " CODECS "\n" + " -f \t\tWrite debug to logfile\n" +#if IR + " -i []\tEnable lirc remote control support (lirc config file ~/.lircrc used if filename not specified)\n" +#endif + " -m \t\tSet mac address, format: ab:cd:ef:12:34:56\n" + " -M \tSet the squeezelite player model name sent to the server (default: " MODEL_NAME_STRING ")\n" + " -n \t\tSet the player name\n" + " -N \t\tStore player name in filename to allow server defined name changes to be shared between servers (not supported with -n)\n" +#if ALSA + " -p \t\tSet real time priority of output thread (1-99)\n" +#endif +#if LINUX || FREEBSD + " -P \t\tStore the process id (PID) in filename\n" +#endif + " -r [:]\tSample rates supported, allows output to be off when squeezelite is started; rates = |-|,,; delay = optional delay switching rates in ms\n" +#if RESAMPLE + " -R -u [params]\tResample, params = ::::::,\n" + " \t\t\t recipe = (v|h|m|l|q)(L|I|M)(s) [E|X], E = exception - resample only if native rate not supported, X = async - resample to max rate for device, otherwise to max sync rate\n" + " \t\t\t flags = num in hex,\n" + " \t\t\t attenuation = attenuation in dB to apply (default is -1db if not explicitly set),\n" + " \t\t\t precision = number of bits precision (NB. HQ = 20. VHQ = 28),\n" + " \t\t\t passband_end = number in percent (0dB pt. bandwidth to preserve. nyquist = 100%%),\n" + " \t\t\t stopband_start = number in percent (Aliasing/imaging control. > passband_end),\n" + " \t\t\t phase_response = 0-100 (0 = minimum / 50 = linear / 100 = maximum)\n" +#endif +#if DSD + " -D [delay]\t\tOutput device supports DSD over PCM (DoP), delay = optional delay switching between PCM and DoP in ms\n" +#endif +#if VISEXPORT + " -v \t\t\tVisualiser support\n" +#endif +# if ALSA + " -L \t\t\tList volume controls for output device\n" + " -U \t\tUnmute ALSA control and set to full volume (not supported with -V)\n" + " -V \t\tUse ALSA control for volume adjustment, otherwise use software volume adjustment\n" +#endif +#if LINUX || FREEBSD + " -z \t\t\tDaemonize\n" +#endif + " -t \t\t\tLicense terms\n" + " -? \t\t\tDisplay this help text\n" + "\n" + "Build options:" +#if LINUX + " LINUX" +#endif +#if WIN + " WIN" +#endif +#if OSX + " OSX" +#endif +#if FREEBSD + " FREEBSD" +#endif +#if ALSA + " ALSA" +#endif +#if PORTAUDIO + " PORTAUDIO" +#endif +#if EVENTFD + " EVENTFD" +#endif +#if SELFPIPE + " SELFPIPE" +#endif +#if WINEVENT + " WINEVENT" +#endif +#if RESAMPLE_MP + " RESAMPLE_MP" +#else +#if RESAMPLE + " RESAMPLE" +#endif +#endif +#if FFMPEG + " FFMPEG" +#endif +#if VISEXPORT + " VISEXPORT" +#endif +#if IR + " IR" +#endif +#if DSD + " DSD" +#endif +#if LINKALL + " LINKALL" +#endif + "\n\n", + argv0); +} + +static void license(void) { + printf(TITLE "\n\n" + "This program is free software: you can redistribute it and/or modify\n" + "it under the terms of the GNU General Public License as published by\n" + "the Free Software Foundation, either version 3 of the License, or\n" + "(at your option) any later version.\n\n" + "This program is distributed in the hope that it will be useful,\n" + "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "GNU General Public License for more details.\n\n" + "You should have received a copy of the GNU General Public License\n" + "along with this program. If not, see .\n\n" +#if DSD + "Contains dsd2pcm library Copyright 2009, 2011 Sebastian Gesemann which\n" + "is subject to its own license.\n\n" +#endif + ); +} + +static void sighandler(int signum) { + slimproto_stop(); + + // remove ourselves in case above does not work, second SIGINT will cause non gracefull shutdown + signal(signum, SIG_DFL); +} + +int main(int argc, char **argv) { + char *server = NULL; + char *output_device = "default"; + char *include_codecs = NULL; + char *exclude_codecs = ""; + char *name = NULL; + char *namefile = NULL; + char *modelname = NULL; + char *logfile = NULL; + u8_t mac[6]; + unsigned stream_buf_size = STREAMBUF_SIZE; + unsigned output_buf_size = 0; // set later + unsigned rates[MAX_SUPPORTED_SAMPLERATES] = { 0 }; + unsigned rate_delay = 0; + char *resample = NULL; + char *output_params = NULL; + unsigned idle = 0; +#if LINUX || FREEBSD + bool daemonize = false; + char *pidfile = NULL; + FILE *pidfp = NULL; +#endif +#if ALSA + unsigned rt_priority = OUTPUT_RT_PRIORITY; + char *output_mixer = NULL; + bool output_mixer_unmute = false; +#endif +#if DSD + bool dop = false; + unsigned dop_delay = 0; +#endif +#if VISEXPORT + bool visexport = false; +#endif +#if IR + char *lircrc = NULL; +#endif + + log_level log_output = lWARN; + log_level log_stream = lWARN; + log_level log_decode = lWARN; + log_level log_slimproto = lWARN; +#if IR + log_level log_ir = lWARN; +#endif + + char *optarg = NULL; + int optind = 1; + int i; + +#define MAXCMDLINE 512 + char cmdline[MAXCMDLINE] = ""; + + get_mac(mac); + + for (i = 0; i < argc && (strlen(argv[i]) + strlen(cmdline) + 2 < MAXCMDLINE); i++) { + strcat(cmdline, argv[i]); + strcat(cmdline, " "); + } + + while (optind < argc && strlen(argv[optind]) >= 2 && argv[optind][0] == '-') { + char *opt = argv[optind] + 1; + if (strstr("oabcCdefmMnNpPrs" +#if ALSA + "UV" +#endif + , opt) && optind < argc - 1) { + optarg = argv[optind + 1]; + optind += 2; + } else if (strstr("ltz?" +#if ALSA + "L" +#endif +#if RESAMPLE + "uR" +#endif +#if DSD + "D" +#endif +#if VISEXPORT + "v" +#endif +#if IR + "i" +#endif + + , opt)) { + optarg = NULL; + optind += 1; + } else { + fprintf(stderr, "\nOption error: -%s\n\n", opt); + usage(argv[0]); + exit(1); + } + + switch (opt[0]) { + case 'o': + output_device = optarg; + break; + case 'a': + output_params = optarg; + break; + case 'b': + { + char *s = next_param(optarg, ':'); + char *o = next_param(NULL, ':'); + if (s) stream_buf_size = atoi(s) * 1024; + if (o) output_buf_size = atoi(o) * 1024; + } + break; + case 'c': + include_codecs = optarg; + break; + case 'C': + if (atoi(optarg) > 0) { + idle = atoi(optarg) * 1000; + } + break; + case 'e': + exclude_codecs = optarg; + break; + case 'd': + { + char *l = strtok(optarg, "="); + char *v = strtok(NULL, "="); + log_level new = lWARN; + if (l && v) { + if (!strcmp(v, "info")) new = lINFO; + if (!strcmp(v, "debug")) new = lDEBUG; + if (!strcmp(v, "sdebug")) new = lSDEBUG; + if (!strcmp(l, "all") || !strcmp(l, "slimproto")) log_slimproto = new; + if (!strcmp(l, "all") || !strcmp(l, "stream")) log_stream = new; + if (!strcmp(l, "all") || !strcmp(l, "decode")) log_decode = new; + if (!strcmp(l, "all") || !strcmp(l, "output")) log_output = new; +#if IR + if (!strcmp(l, "all") || !strcmp(l, "ir")) log_ir = new; +#endif + } else { + fprintf(stderr, "\nDebug settings error: -d %s\n\n", optarg); + usage(argv[0]); + exit(1); + } + } + break; + case 'f': + logfile = optarg; + break; + case 'm': + { + int byte = 0; + char *tmp; + if (!strncmp(optarg, "00:04:20", 8)) { + LOG_ERROR("ignoring mac address from hardware player range 00:04:20:**:**:**"); + } else { + char *t = strtok(optarg, ":"); + while (t && byte < 6) { + mac[byte++] = (u8_t)strtoul(t, &tmp, 16); + t = strtok(NULL, ":"); + } + } + } + break; + case 'M': + modelname = optarg; + break; + case 'r': + { + char *rstr = next_param(optarg, ':'); + char *dstr = next_param(NULL, ':'); + if (rstr && strstr(rstr, ",")) { + // parse sample rates and sort them + char *r = next_param(rstr, ','); + unsigned tmp[MAX_SUPPORTED_SAMPLERATES] = { 0 }; + int i, j; + int last = 999999; + for (i = 0; r && i < MAX_SUPPORTED_SAMPLERATES; ++i) { + tmp[i] = atoi(r); + r = next_param(NULL, ','); + } + for (i = 0; i < MAX_SUPPORTED_SAMPLERATES; ++i) { + int largest = 0; + for (j = 0; j < MAX_SUPPORTED_SAMPLERATES; ++j) { + if (tmp[j] > largest && tmp[j] < last) { + largest = tmp[j]; + } + } + rates[i] = last = largest; + } + } else if (rstr) { + // optstr is - or , extract rates from test rates within this range + unsigned ref[] TEST_RATES; + char *str1 = next_param(rstr, '-'); + char *str2 = next_param(NULL, '-'); + unsigned max = str2 ? atoi(str2) : (str1 ? atoi(str1) : ref[0]); + unsigned min = str1 && str2 ? atoi(str1) : 0; + unsigned tmp; + int i, j; + if (max < min) { tmp = max; max = min; min = tmp; } + rates[0] = max; + for (i = 0, j = 1; i < MAX_SUPPORTED_SAMPLERATES; ++i) { + if (ref[i] < rates[j-1] && ref[i] >= min) { + rates[j++] = ref[i]; + } + } + } + if (dstr) { + rate_delay = atoi(dstr); + } + } + break; + case 's': + server = optarg; + break; + case 'n': + name = optarg; + break; + case 'N': + namefile = optarg; + break; +#if ALSA + case 'p': + rt_priority = atoi(optarg); + if (rt_priority > 99 || rt_priority < 1) { + fprintf(stderr, "\nError: invalid priority: %s\n\n", optarg); + usage(argv[0]); + exit(1); + } + break; +#endif +#if LINUX || FREEBSD + case 'P': + pidfile = optarg; + break; +#endif + case 'l': + list_devices(); + exit(0); + break; +#if ALSA + case 'L': + list_mixers(output_device); + exit(0); + break; +#endif +#if RESAMPLE + case 'u': + case 'R': + if (optind < argc && argv[optind] && argv[optind][0] != '-') { + resample = argv[optind++]; + } else { + resample = ""; + } + break; +#endif +#if DSD + case 'D': + dop = true; + if (optind < argc && argv[optind] && argv[optind][0] != '-') { + dop_delay = atoi(argv[optind++]); + } + break; +#endif +#if VISEXPORT + case 'v': + visexport = true; + break; +#endif +#if ALSA + case 'U': + output_mixer_unmute = true; + case 'V': + if (output_mixer) { + fprintf(stderr, "-U and -V option should not be used at same time\n"); + exit(1); + } + output_mixer = optarg; + break; +#endif +#if IR + case 'i': + if (optind < argc && argv[optind] && argv[optind][0] != '-') { + lircrc = argv[optind++]; + } else { + lircrc = "~/.lircrc"; // liblirc_client will expand ~/ + } + break; +#endif +#if LINUX || FREEBSD + case 'z': + daemonize = true; + break; +#endif + case 't': + license(); + exit(0); + case '?': + usage(argv[0]); + exit(0); + default: + fprintf(stderr, "Arg error: %s\n", argv[optind]); + break; + } + } + + // warn if command line includes something which isn't parsed + if (optind < argc) { + fprintf(stderr, "\nError: command line argument error\n\n"); + usage(argv[0]); + exit(1); + } + + signal(SIGINT, sighandler); + signal(SIGTERM, sighandler); +#if defined(SIGQUIT) + signal(SIGQUIT, sighandler); +#endif +#if defined(SIGHUP) + signal(SIGHUP, sighandler); +#endif + + // set the output buffer size if not specified on the command line, take account of resampling + if (!output_buf_size) { + output_buf_size = OUTPUTBUF_SIZE; + if (resample) { + unsigned scale = 8; + if (rates[0]) { + scale = rates[0] / 44100; + if (scale > 8) scale = 8; + if (scale < 1) scale = 1; + } + output_buf_size *= scale; + } + } + + if (logfile) { + if (!freopen(logfile, "a", stderr)) { + fprintf(stderr, "error opening logfile %s: %s\n", logfile, strerror(errno)); + } else { + if (log_output >= lINFO || log_stream >= lINFO || log_decode >= lINFO || log_slimproto >= lINFO) { + fprintf(stderr, "\n%s\n", cmdline); + } + } + } + +#if LINUX || FREEBSD + if (pidfile) { + if (!(pidfp = fopen(pidfile, "w")) ) { + fprintf(stderr, "Error opening pidfile %s: %s\n", pidfile, strerror(errno)); + exit(1); + } + pidfile = realpath(pidfile, NULL); // daemonize will change cwd + } + + if (daemonize) { + if (daemon(0, logfile ? 1 : 0)) { + fprintf(stderr, "error daemonizing: %s\n", strerror(errno)); + } + } + + if (pidfp) { + fprintf(pidfp, "%d\n", getpid()); + fclose(pidfp); + } +#endif + +#if WIN + winsock_init(); +#endif + + stream_init(log_stream, stream_buf_size); + + if (!strcmp(output_device, "-")) { + output_init_stdout(log_output, output_buf_size, output_params, rates, rate_delay); + } else { +#if ALSA + output_init_alsa(log_output, output_device, output_buf_size, output_params, rates, rate_delay, rt_priority, idle, output_mixer, + output_mixer_unmute); +#endif +#if PORTAUDIO + output_init_pa(log_output, output_device, output_buf_size, output_params, rates, rate_delay, idle); +#endif + } + +#if DSD + dop_init(dop, dop_delay); +#endif + +#if VISEXPORT + if (visexport) { + output_vis_init(log_output, mac); + } +#endif + + decode_init(log_decode, include_codecs, exclude_codecs); + +#if RESAMPLE + if (resample) { + process_init(resample); + } +#endif + +#if IR + if (lircrc) { + ir_init(log_ir, lircrc); + } +#endif + + if (name && namefile) { + fprintf(stderr, "-n and -N option should not be used at same time\n"); + exit(1); + } + + slimproto(log_slimproto, server, mac, name, namefile, modelname); + + decode_close(); + stream_close(); + + if (!strcmp(output_device, "-")) { + output_close_stdout(); + } else { +#if ALSA + output_close_alsa(); +#endif +#if PORTAUDIO + output_close_pa(); +#endif + } + +#if IR + ir_close(); +#endif + +#if WIN + winsock_close(); +#endif + +#if LINUX || FREEBSD + if (pidfile) { + unlink(pidfile); + free(pidfile); + } +#endif + + exit(0); +} diff --git a/mpg.c b/mpg.c new file mode 100644 index 0000000..f3074f2 --- /dev/null +++ b/mpg.c @@ -0,0 +1,276 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#include "squeezelite.h" + +#include + +#define READ_SIZE 512 +#define WRITE_SIZE 32 * 1024 + +struct mpg { + mpg123_handle *h; + bool use16bit; +#if !LINKALL + // mpg symbols to be dynamically loaded + int (* mpg123_init)(void); + int (* mpg123_feature)(const enum mpg123_feature_set); + void (* mpg123_rates)(const long **, size_t *); + int (* mpg123_format_none)(mpg123_handle *); + int (* mpg123_format)(mpg123_handle *, long, int, int); + mpg123_handle *(* mpg123_new)(const char*, int *); + void (* mpg123_delete)(mpg123_handle *); + int (* mpg123_open_feed)(mpg123_handle *); + int (* mpg123_decode)(mpg123_handle *, const unsigned char *, size_t, unsigned char *, size_t, size_t *); + int (* mpg123_getformat)(mpg123_handle *, long *, int *, int *); + const char* (* mpg123_plain_strerror)(int); +#endif +}; + +static struct mpg *m; + +extern log_level loglevel; + +extern struct buffer *streambuf; +extern struct buffer *outputbuf; +extern struct streamstate stream; +extern struct outputstate output; +extern struct decodestate decode; +extern struct processstate process; + +#define LOCK_S mutex_lock(streambuf->mutex) +#define UNLOCK_S mutex_unlock(streambuf->mutex) +#define LOCK_O mutex_lock(outputbuf->mutex) +#define UNLOCK_O mutex_unlock(outputbuf->mutex) +#if PROCESS +#define LOCK_O_direct if (decode.direct) mutex_lock(outputbuf->mutex) +#define UNLOCK_O_direct if (decode.direct) mutex_unlock(outputbuf->mutex) +#define LOCK_O_not_direct if (!decode.direct) mutex_lock(outputbuf->mutex) +#define UNLOCK_O_not_direct if (!decode.direct) mutex_unlock(outputbuf->mutex) +#define IF_DIRECT(x) if (decode.direct) { x } +#define IF_PROCESS(x) if (!decode.direct) { x } +#else +#define LOCK_O_direct mutex_lock(outputbuf->mutex) +#define UNLOCK_O_direct mutex_unlock(outputbuf->mutex) +#define LOCK_O_not_direct +#define UNLOCK_O_not_direct +#define IF_DIRECT(x) { x } +#define IF_PROCESS(x) +#endif + +#if LINKALL +#define MPG123(h, fn, ...) (mpg123_ ## fn)(__VA_ARGS__) +#else +#define MPG123(h, fn, ...) (h)->mpg123_##fn(__VA_ARGS__) +#endif + +static decode_state mpg_decode(void) { + size_t bytes, space, size; + int ret; + u8_t *write_buf; + + LOCK_S; + LOCK_O_direct; + bytes = min(_buf_used(streambuf), _buf_cont_read(streambuf)); + + IF_DIRECT( + space = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)); + write_buf = outputbuf->writep; + ); + IF_PROCESS( + space = process.max_in_frames; + write_buf = process.inbuf; + ); + + bytes = min(bytes, READ_SIZE); + space = min(space, WRITE_SIZE); + + if (m->use16bit) { + space = (space / BYTES_PER_FRAME) * 4; + } + + // only get the new stream information on first call so we can reset decode.direct appropriately + if (decode.new_stream) { + space = 0; + } + + ret = MPG123(m, decode, m->h, streambuf->readp, bytes, write_buf, space, &size); + + if (ret == MPG123_NEW_FORMAT) { + + if (decode.new_stream) { + long rate; + int channels, enc; + + MPG123(m, getformat, m->h, &rate, &channels, &enc); + + LOG_INFO("setting track_start"); + LOCK_O_not_direct; + output.next_sample_rate = decode_newstream(rate, output.supported_rates); + IF_DSD( output.next_dop = false; ) + output.track_start = outputbuf->writep; + if (output.fade_mode) _checkfade(true); + decode.new_stream = false; + UNLOCK_O_not_direct; + + } else { + LOG_WARN("format change mid stream - not supported"); + } + } + + // expand 16bit output to 32bit samples + if (m->use16bit) { + s16_t *iptr; + s32_t *optr; + size_t count = size / 2; + size = count * 4; + iptr = (s16_t *)write_buf + count; + optr = (s32_t *)write_buf + count; + while (count--) { + *--optr = *--iptr << 16; + } + } + + _buf_inc_readp(streambuf, bytes); + + IF_DIRECT( + _buf_inc_writep(outputbuf, size); + ); + IF_PROCESS( + process.in_frames = size / BYTES_PER_FRAME; + ); + + UNLOCK_O_direct; + + LOG_SDEBUG("write %u frames", size / BYTES_PER_FRAME); + + if (ret == MPG123_DONE || (bytes == 0 && size == 0 && stream.state <= DISCONNECT)) { + UNLOCK_S; + LOG_INFO("stream complete"); + return DECODE_COMPLETE; + } + + UNLOCK_S; + + if (ret == MPG123_ERR) { + LOG_WARN("Error"); + return DECODE_COMPLETE; + } + + // OK and NEED_MORE keep running + return DECODE_RUNNING; +} + +static void mpg_open(u8_t size, u8_t rate, u8_t chan, u8_t endianness) { + int err; + const long *list; + size_t count, i; + + if (m->h) { + MPG123(m, delete, m->h); + } + + m->h = MPG123(m, new, NULL, &err); + + if (m->h == NULL) { + LOG_WARN("new error: %s", MPG123(m, plain_strerror, err)); + } + + // restrict output to 32bit or 16bit signed 2 channel based on library capability + MPG123(m, rates, &list, &count); + MPG123(m, format_none, m->h); + for (i = 0; i < count; i++) { + MPG123(m, format, m->h, list[i], 2, m->use16bit ? MPG123_ENC_SIGNED_16 : MPG123_ENC_SIGNED_32); + } + + err = MPG123(m, open_feed, m->h); + + if (err) { + LOG_WARN("open feed error: %s", MPG123(m, plain_strerror, err)); + } +} + +static void mpg_close(void) { + MPG123(m, delete, m->h); + m->h = NULL; +} + +static bool load_mpg() { +#if !LINKALL + void *handle = dlopen(LIBMPG, RTLD_NOW); + char *err; + + if (!handle) { + LOG_INFO("dlerror: %s", dlerror()); + return false; + } + + m->mpg123_init = dlsym(handle, "mpg123_init"); + m->mpg123_feature = dlsym(handle, "mpg123_feature"); + m->mpg123_rates = dlsym(handle, "mpg123_rates"); + m->mpg123_format_none = dlsym(handle, "mpg123_format_none"); + m->mpg123_format = dlsym(handle, "mpg123_format"); + m->mpg123_new = dlsym(handle, "mpg123_new"); + m->mpg123_delete = dlsym(handle, "mpg123_delete"); + m->mpg123_open_feed = dlsym(handle, "mpg123_open_feed"); + m->mpg123_decode = dlsym(handle, "mpg123_decode"); + m->mpg123_getformat = dlsym(handle, "mpg123_getformat"); + m->mpg123_plain_strerror = dlsym(handle, "mpg123_plain_strerror"); + + if ((err = dlerror()) != NULL) { + LOG_INFO("dlerror: %s", err); + return false; + } + + LOG_INFO("loaded "LIBMPG); +#endif + + return true; +} + +struct codec *register_mpg(void) { + static struct codec ret = { + 'm', // id + "mp3", // types + READ_SIZE, // min read + WRITE_SIZE, // min space + mpg_open, // open + mpg_close, // close + mpg_decode, // decode + }; + + m = malloc(sizeof(struct mpg)); + if (!m) { + return NULL; + } + + m->h = NULL; + + if (!load_mpg()) { + return NULL; + } + + MPG123(m, init); + + m->use16bit = MPG123(m, feature, MPG123_FEATURE_OUTPUT_32BIT); + + LOG_INFO("using mpg to decode mp3"); + return &ret; +} diff --git a/output.c b/output.c new file mode 100644 index 0000000..6176c8b --- /dev/null +++ b/output.c @@ -0,0 +1,436 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// Common output function + +#include "squeezelite.h" + +static log_level loglevel; + +struct outputstate output; + +static struct buffer buf; + +struct buffer *outputbuf = &buf; + +u8_t *silencebuf; +#if DSD +u8_t *silencebuf_dop; +#endif + +#define LOCK mutex_lock(outputbuf->mutex) +#define UNLOCK mutex_unlock(outputbuf->mutex) + +// functions starting _* are called with mutex locked + +frames_t _output_frames(frames_t avail) { + + frames_t frames, size; + bool silence; + + s32_t cross_gain_in = 0, cross_gain_out = 0; s32_t *cross_ptr = NULL; + + s32_t gainL = output.current_replay_gain ? gain(output.gainL, output.current_replay_gain) : output.gainL; + s32_t gainR = output.current_replay_gain ? gain(output.gainR, output.current_replay_gain) : output.gainR; + + if (output.invert) { gainL = -gainL; gainR = -gainR; } + + frames = _buf_used(outputbuf) / BYTES_PER_FRAME; + silence = false; + + // start when threshold met + if (output.state == OUTPUT_BUFFER && frames > output.threshold * output.next_sample_rate / 100 && frames > output.start_frames) { + output.state = OUTPUT_RUNNING; + LOG_INFO("start buffer frames: %u", frames); + wake_controller(); + } + + // skip ahead - consume outputbuf but play nothing + if (output.state == OUTPUT_SKIP_FRAMES) { + if (frames > 0) { + frames_t skip = min(frames, output.skip_frames); + LOG_INFO("skip %u of %u frames", skip, output.skip_frames); + frames -= skip; + output.frames_played += skip; + while (skip > 0) { + frames_t cont_frames = min(skip, _buf_cont_read(outputbuf) / BYTES_PER_FRAME); + skip -= cont_frames; + _buf_inc_readp(outputbuf, cont_frames * BYTES_PER_FRAME); + } + } + output.state = OUTPUT_RUNNING; + } + + // pause frames - play silence for required frames + if (output.state == OUTPUT_PAUSE_FRAMES) { + LOG_INFO("pause %u frames", output.pause_frames); + if (output.pause_frames == 0) { + output.state = OUTPUT_RUNNING; + } else { + silence = true; + frames = min(avail, output.pause_frames); + frames = min(frames, MAX_SILENCE_FRAMES); + output.pause_frames -= frames; + } + } + + // start at - play silence until jiffies reached + if (output.state == OUTPUT_START_AT) { + u32_t now = gettime_ms(); + if (now >= output.start_at || output.start_at > now + 10000) { + output.state = OUTPUT_RUNNING; + } else { + u32_t delta_frames = (output.start_at - now) * output.current_sample_rate / 1000; + silence = true; + frames = min(avail, delta_frames); + frames = min(frames, MAX_SILENCE_FRAMES); + } + } + + // play silence if buffering or no frames + if (output.state <= OUTPUT_BUFFER || frames == 0) { + silence = true; + frames = min(avail, MAX_SILENCE_FRAMES); + } + + LOG_SDEBUG("avail: %d frames: %d silence: %d", avail, frames, silence); + frames = min(frames, avail); + size = frames; + + while (size > 0) { + frames_t out_frames; + frames_t cont_frames = _buf_cont_read(outputbuf) / BYTES_PER_FRAME; + int wrote; + + if (output.track_start && !silence) { + if (output.track_start == outputbuf->readp) { + unsigned delay = 0; + if (output.current_sample_rate != output.next_sample_rate) { + delay = output.rate_delay; + } + IF_DSD( + if (output.dop != output.next_dop) { + delay = output.dop_delay; + } + ) + frames -= size; + // add silence delay in two halves, before and after track start on rate or pcm-dop change + if (delay) { + output.state = OUTPUT_PAUSE_FRAMES; + if (!output.delay_active) { + output.pause_frames = output.current_sample_rate * delay / 2000; + output.delay_active = true; // first delay - don't process track start + break; + } else { + output.pause_frames = output.next_sample_rate * delay / 2000; + output.delay_active = false; // second delay - process track start + } + } + LOG_INFO("track start sample rate: %u replay_gain: %u", output.next_sample_rate, output.next_replay_gain); + output.frames_played = 0; + output.track_started = true; + output.track_start_time = gettime_ms(); + output.current_sample_rate = output.next_sample_rate; + IF_DSD( + output.dop = output.next_dop; + ) + if (!output.fade == FADE_ACTIVE || !output.fade_mode == FADE_CROSSFADE) { + output.current_replay_gain = output.next_replay_gain; + } + output.track_start = NULL; + break; + } else if (output.track_start > outputbuf->readp) { + // reduce cont_frames so we find the next track start at beginning of next chunk + cont_frames = min(cont_frames, (output.track_start - outputbuf->readp) / BYTES_PER_FRAME); + } + } + + IF_DSD( + if (output.dop) { + gainL = gainR = FIXED_ONE; + } + ) + + if (output.fade && !silence) { + if (output.fade == FADE_DUE) { + if (output.fade_start == outputbuf->readp) { + LOG_INFO("fade start reached"); + output.fade = FADE_ACTIVE; + } else if (output.fade_start > outputbuf->readp) { + cont_frames = min(cont_frames, (output.fade_start - outputbuf->readp) / BYTES_PER_FRAME); + } + } + if (output.fade == FADE_ACTIVE) { + // find position within fade + frames_t cur_f = outputbuf->readp >= output.fade_start ? (outputbuf->readp - output.fade_start) / BYTES_PER_FRAME : + (outputbuf->readp + outputbuf->size - output.fade_start) / BYTES_PER_FRAME; + frames_t dur_f = output.fade_end >= output.fade_start ? (output.fade_end - output.fade_start) / BYTES_PER_FRAME : + (output.fade_end + outputbuf->size - output.fade_start) / BYTES_PER_FRAME; + if (cur_f >= dur_f) { + if (output.fade_mode == FADE_INOUT && output.fade_dir == FADE_DOWN) { + LOG_INFO("fade down complete, starting fade up"); + output.fade_dir = FADE_UP; + output.fade_start = outputbuf->readp; + output.fade_end = outputbuf->readp + dur_f * BYTES_PER_FRAME; + if (output.fade_end >= outputbuf->wrap) { + output.fade_end -= outputbuf->size; + } + cur_f = 0; + } else if (output.fade_mode == FADE_CROSSFADE) { + LOG_INFO("crossfade complete"); + if (_buf_used(outputbuf) >= dur_f * BYTES_PER_FRAME) { + _buf_inc_readp(outputbuf, dur_f * BYTES_PER_FRAME); + LOG_INFO("skipped crossfaded start"); + } else { + LOG_WARN("unable to skip crossfaded start"); + } + output.fade = FADE_INACTIVE; + output.current_replay_gain = output.next_replay_gain; + } else { + LOG_INFO("fade complete"); + output.fade = FADE_INACTIVE; + } + } + // if fade in progress set fade gain, ensure cont_frames reduced so we get to end of fade at start of chunk + if (output.fade) { + if (output.fade_end > outputbuf->readp) { + cont_frames = min(cont_frames, (output.fade_end - outputbuf->readp) / BYTES_PER_FRAME); + } + if (output.fade_dir == FADE_UP || output.fade_dir == FADE_DOWN) { + // fade in, in-out, out handled via altering standard gain + s32_t fade_gain; + if (output.fade_dir == FADE_DOWN) { + cur_f = dur_f - cur_f; + } + fade_gain = to_gain((float)cur_f / (float)dur_f); + gainL = gain(gainL, fade_gain); + gainR = gain(gainR, fade_gain); + if (output.invert) { gainL = -gainL; gainR = -gainR; } + } + if (output.fade_dir == FADE_CROSS) { + // cross fade requires special treatment - performed later based on these values + // support different replay gain for old and new track by retaining old value until crossfade completes + if (_buf_used(outputbuf) / BYTES_PER_FRAME > dur_f + size) { + cross_gain_in = to_gain((float)cur_f / (float)dur_f); + cross_gain_out = FIXED_ONE - cross_gain_in; + if (output.current_replay_gain) { + cross_gain_out = gain(cross_gain_out, output.current_replay_gain); + } + if (output.next_replay_gain) { + cross_gain_in = gain(cross_gain_in, output.next_replay_gain); + } + gainL = output.gainL; + gainR = output.gainR; + if (output.invert) { gainL = -gainL; gainR = -gainR; } + cross_ptr = (s32_t *)(output.fade_end + cur_f * BYTES_PER_FRAME); + } else { + LOG_INFO("unable to continue crossfade - too few samples"); + output.fade = FADE_INACTIVE; + } + } + } + } + } + + out_frames = !silence ? min(size, cont_frames) : size; + + wrote = output.write_cb(out_frames, silence, gainL, gainR, cross_gain_in, cross_gain_out, &cross_ptr); + + if (wrote <= 0) { + frames -= size; + break; + } else { + out_frames = (frames_t)wrote; + } + + size -= out_frames; + + _vis_export(outputbuf, &output, out_frames, silence); + + if (!silence) { + _buf_inc_readp(outputbuf, out_frames * BYTES_PER_FRAME); + output.frames_played += out_frames; + } + } + + LOG_SDEBUG("wrote %u frames", frames); + + return frames; +} + +void _checkfade(bool start) { + frames_t bytes; + + LOG_INFO("fade mode: %u duration: %u %s", output.fade_mode, output.fade_secs, start ? "track-start" : "track-end"); + + bytes = output.next_sample_rate * BYTES_PER_FRAME * output.fade_secs; + if (output.fade_mode == FADE_INOUT) { + bytes /= 2; + } + + if (start && (output.fade_mode == FADE_IN || (output.fade_mode == FADE_INOUT && _buf_used(outputbuf) == 0))) { + bytes = min(bytes, outputbuf->size - BYTES_PER_FRAME); // shorter than full buffer otherwise start and end align + LOG_INFO("fade IN: %u frames", bytes / BYTES_PER_FRAME); + output.fade = FADE_DUE; + output.fade_dir = FADE_UP; + output.fade_start = outputbuf->writep; + output.fade_end = output.fade_start + bytes; + if (output.fade_end >= outputbuf->wrap) { + output.fade_end -= outputbuf->size; + } + } + + if (!start && (output.fade_mode == FADE_OUT || output.fade_mode == FADE_INOUT)) { + bytes = min(_buf_used(outputbuf), bytes); + LOG_INFO("fade %s: %u frames", output.fade_mode == FADE_INOUT ? "IN-OUT" : "OUT", bytes / BYTES_PER_FRAME); + output.fade = FADE_DUE; + output.fade_dir = FADE_DOWN; + output.fade_start = outputbuf->writep - bytes; + if (output.fade_start < outputbuf->buf) { + output.fade_start += outputbuf->size; + } + output.fade_end = outputbuf->writep; + } + + if (start && output.fade_mode == FADE_CROSSFADE) { + if (_buf_used(outputbuf) != 0) { + if (output.next_sample_rate != output.current_sample_rate) { + LOG_INFO("crossfade disabled as sample rates differ"); + return; + } + bytes = min(bytes, _buf_used(outputbuf)); // max of current remaining samples from previous track + bytes = min(bytes, (frames_t)(outputbuf->size * 0.9)); // max of 90% of outputbuf as we consume additional buffer during crossfade + LOG_INFO("CROSSFADE: %u frames", bytes / BYTES_PER_FRAME); + output.fade = FADE_DUE; + output.fade_dir = FADE_CROSS; + output.fade_start = outputbuf->writep - bytes; + if (output.fade_start < outputbuf->buf) { + output.fade_start += outputbuf->size; + } + output.fade_end = outputbuf->writep; + output.track_start = output.fade_start; + } else if (outputbuf->size == OUTPUTBUF_SIZE && outputbuf->readp == outputbuf->buf) { + // if default setting used and nothing in buffer attempt to resize to provide full crossfade support + LOG_INFO("resize outputbuf for crossfade"); + _buf_resize(outputbuf, OUTPUTBUF_SIZE_CROSSFADE); +#if LINUX || FREEBSD + touch_memory(outputbuf->buf, outputbuf->size); +#endif + } + } +} + +void output_init_common(log_level level, const char *device, unsigned output_buf_size, unsigned rates[], unsigned idle) { + unsigned i; + + loglevel = level; + + output_buf_size = output_buf_size - (output_buf_size % BYTES_PER_FRAME); + LOG_DEBUG("outputbuf size: %u", output_buf_size); + + buf_init(outputbuf, output_buf_size); + if (!outputbuf->buf) { + LOG_ERROR("unable to malloc output buffer"); + exit(0); + } + + silencebuf = malloc(MAX_SILENCE_FRAMES * BYTES_PER_FRAME); + if (!silencebuf) { + LOG_ERROR("unable to malloc silence buffer"); + exit(0); + } + memset(silencebuf, 0, MAX_SILENCE_FRAMES * BYTES_PER_FRAME); + + IF_DSD( + silencebuf_dop = malloc(MAX_SILENCE_FRAMES * BYTES_PER_FRAME); + if (!silencebuf_dop) { + LOG_ERROR("unable to malloc silence dop buffer"); + exit(0); + } + dop_silence_frames((u32_t *)silencebuf_dop, MAX_SILENCE_FRAMES); + ) + + LOG_DEBUG("idle timeout: %u", idle); + + output.state = idle ? OUTPUT_OFF: OUTPUT_STOPPED; + output.device = device; + output.fade = FADE_INACTIVE; + output.invert = false; + output.error_opening = false; + output.idle_to = (u32_t) idle; + + if (!rates[0]) { + if (!test_open(output.device, output.supported_rates)) { + LOG_ERROR("unable to open output device"); + exit(0); + } + } else { + for (i = 0; i < MAX_SUPPORTED_SAMPLERATES; ++i) { + output.supported_rates[i] = rates[i]; + } + } + + // set initial sample rate, preferring 44100 + for (i = 0; i < MAX_SUPPORTED_SAMPLERATES; ++i) { + if (output.supported_rates[i] == 44100) { + output.default_sample_rate = 44100; + break; + } + } + if (!output.default_sample_rate) { + output.default_sample_rate = output.supported_rates[0]; + } + + output.current_sample_rate = output.default_sample_rate; + + if (loglevel >= lINFO) { + char rates_buf[10 * MAX_SUPPORTED_SAMPLERATES] = ""; + for (i = 0; output.supported_rates[i]; ++i) { + char s[10]; + sprintf(s, "%d ", output.supported_rates[i]); + strcat(rates_buf, s); + } + LOG_INFO("supported rates: %s", rates_buf); + } +} + +void output_close_common(void) { + buf_destroy(outputbuf); + free(silencebuf); + IF_DSD( + free(silencebuf_dop); + ) +} + +void output_flush(void) { + LOG_INFO("flush output buffer"); + buf_flush(outputbuf); + LOCK; + output.fade = FADE_INACTIVE; + if (output.state != OUTPUT_OFF) { + output.state = OUTPUT_STOPPED; + if (output.error_opening) { + output.current_sample_rate = output.default_sample_rate; + } + output.delay_active = false; + } + output.frames_played = 0; + UNLOCK; +} diff --git a/output_alsa.c b/output_alsa.c new file mode 100644 index 0000000..aa01560 --- /dev/null +++ b/output_alsa.c @@ -0,0 +1,904 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// Output using Alsa + +#include "squeezelite.h" + +#if ALSA + +#include +#include +#include +#include + +#define MAX_DEVICE_LEN 128 + +static snd_pcm_format_t fmts[] = { SND_PCM_FORMAT_S32_LE, SND_PCM_FORMAT_S24_LE, SND_PCM_FORMAT_S24_3LE, SND_PCM_FORMAT_S16_LE, + SND_PCM_FORMAT_UNKNOWN }; + +#if SL_LITTLE_ENDIAN +#define NATIVE_FORMAT SND_PCM_FORMAT_S32_LE +#else +#define NATIVE_FORMAT SND_PCM_FORMAT_S32_BE +#endif + +// ouput device +static struct { + char device[MAX_DEVICE_LEN + 1]; + snd_pcm_format_t format; + snd_pcm_uframes_t buffer_size; + snd_pcm_uframes_t period_size; + unsigned rate; + bool mmap; + bool reopen; + u8_t *write_buf; + const char *volume_mixer_name; + int volume_mixer_index; +} alsa; + +static snd_pcm_t *pcmp = NULL; + +extern u8_t *silencebuf; +#if DSD +extern u8_t *silencebuf_dop; +#endif + +static log_level loglevel; + +static bool running = true; + +extern struct outputstate output; +extern struct buffer *outputbuf; + +#define LOCK mutex_lock(outputbuf->mutex) +#define UNLOCK mutex_unlock(outputbuf->mutex) + +void list_devices(void) { + void **hints, **n; + if (snd_device_name_hint(-1, "pcm", &hints) >= 0) { + n = hints; + printf("Output devices:\n"); + while (*n) { + char *name = snd_device_name_get_hint(*n, "NAME"); + char *desc = snd_device_name_get_hint(*n, "DESC"); + if (name) printf(" %-30s", name); + if (desc) { + char *s1 = strtok(desc, "\n"); + char *s2 = strtok(NULL, "\n"); + if (s1) printf(" - %s", s1); + if (s2) printf(" - %s", s2); + } + printf("\n"); + if (name) free(name); + if (desc) free(desc); + n++; + } + snd_device_name_free_hint(hints); + } + printf("\n"); +} + +void list_mixers(const char *output_device) { + int err; + snd_mixer_t *handle; + snd_mixer_selem_id_t *sid; + snd_mixer_elem_t *elem; + snd_mixer_selem_id_alloca(&sid); + + LOG_INFO("listing mixers for: %s", output_device); + + if ((err = snd_mixer_open(&handle, 0)) < 0) { + LOG_ERROR("open error: %s", snd_strerror(err)); + return; + } + if ((err = snd_mixer_attach(handle, output_device)) < 0) { + LOG_ERROR("attach error: %s", snd_strerror(err)); + snd_mixer_close(handle); + return; + } + if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) { + LOG_ERROR("register error: %s", snd_strerror(err)); + snd_mixer_close(handle); + return; + } + if ((err = snd_mixer_load(handle)) < 0) { + LOG_ERROR("load error: %s", snd_strerror(err)); + snd_mixer_close(handle); + return; + } + + printf("Volume controls for %s\n", output_device); + for (elem = snd_mixer_first_elem(handle); elem; elem = snd_mixer_elem_next(elem)) { + if (snd_mixer_selem_has_playback_volume(elem)) { + snd_mixer_selem_get_id(elem, sid); + printf(" %s", snd_mixer_selem_id_get_name(sid)); + if (snd_mixer_selem_id_get_index(sid)) { + printf(",%d", snd_mixer_selem_id_get_index(sid)); + } + printf("\n"); + } + } + printf("\n"); + + snd_mixer_close(handle); +} + +#define MINVOL_DB 72 // LMS volume map for SqueezePlay sends values in range ~ -72..0 dB + +static void set_mixer(const char *device, const char *mixer, int mixer_index, bool setmax, float ldB, float rdB) { + int err; + long nleft, nright; + long min, max; + snd_mixer_t *handle; + snd_mixer_selem_id_t *sid; + snd_mixer_elem_t* elem; + + if ((err = snd_mixer_open(&handle, 0)) < 0) { + LOG_ERROR("open error: %s", snd_strerror(err)); + return; + } + if ((err = snd_mixer_attach(handle, device)) < 0) { + LOG_ERROR("attach error: %s", snd_strerror(err)); + snd_mixer_close(handle); + return; + } + if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) { + LOG_ERROR("register error: %s", snd_strerror(err)); + snd_mixer_close(handle); + return; + } + if ((err = snd_mixer_load(handle)) < 0) { + LOG_ERROR("load error: %s", snd_strerror(err)); + snd_mixer_close(handle); + return; + } + + snd_mixer_selem_id_alloca(&sid); + + snd_mixer_selem_id_set_index(sid, mixer_index); + snd_mixer_selem_id_set_name(sid, mixer); + + if ((elem = snd_mixer_find_selem(handle, sid)) == NULL) { + LOG_ERROR("error find selem %s", mixer); + snd_mixer_close(handle); + return; + } + + if (snd_mixer_selem_has_playback_switch(elem)) { + snd_mixer_selem_set_playback_switch_all(elem, 1); // unmute + } + + err = snd_mixer_selem_get_playback_dB_range(elem, &min, &max); + + if (err < 0 || max - min < 1000) { + // unable to get db range or range is less than 10dB - ignore and set using raw values + if ((err = snd_mixer_selem_get_playback_volume_range(elem, &min, &max)) < 0) { + LOG_ERROR("unable to get volume raw range"); + } else { + long lraw, rraw; + if (setmax) { + lraw = rraw = max; + } else { + lraw = ((ldB > -MINVOL_DB ? MINVOL_DB + floor(ldB) : 0) / MINVOL_DB * (max-min)) + min; + rraw = ((rdB > -MINVOL_DB ? MINVOL_DB + floor(rdB) : 0) / MINVOL_DB * (max-min)) + min; + } + LOG_DEBUG("setting vol raw [%ld..%ld]", min, max); + if ((err = snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, lraw)) < 0) { + LOG_ERROR("error setting left volume: %s", snd_strerror(err)); + } + if ((err = snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, rraw)) < 0) { + LOG_ERROR("error setting right volume: %s", snd_strerror(err)); + } + } + } else { + // set db directly + LOG_DEBUG("setting vol dB [%ld..%ld]", min, max); + if (setmax) { + // set to 0dB if available as this should be max volume for music recored at max pcm values + if (max >= 0 && min <= 0) { + ldB = rdB = 0; + } else { + ldB = rdB = max; + } + } + if ((err = snd_mixer_selem_set_playback_dB(elem, SND_MIXER_SCHN_FRONT_LEFT, 100 * ldB, 1)) < 0) { + LOG_ERROR("error setting left volume: %s", snd_strerror(err)); + } + if ((err = snd_mixer_selem_set_playback_dB(elem, SND_MIXER_SCHN_FRONT_RIGHT, 100 * rdB, 1)) < 0) { + LOG_ERROR("error setting right volume: %s", snd_strerror(err)); + } + } + + if ((err = snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &nleft)) < 0) { + LOG_ERROR("error getting left vol: %s", snd_strerror(err)); + } + if ((err = snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &nright)) < 0) { + LOG_ERROR("error getting right vol: %s", snd_strerror(err)); + } + + LOG_DEBUG("%s left: %3.1fdB -> %ld right: %3.1fdB -> %ld", mixer, ldB, nleft, rdB, nright); + + snd_mixer_close(handle); +} + +void set_volume(unsigned left, unsigned right) { + float ldB, rdB; + + if (!alsa.volume_mixer_name) { + LOG_DEBUG("setting internal gain left: %u right: %u", left, right); + LOCK; + output.gainL = left; + output.gainR = right; + UNLOCK; + return; + } else { + LOCK; + output.gainL = FIXED_ONE; + output.gainR = FIXED_ONE; + UNLOCK; + } + + // convert 16.16 fixed point to dB + ldB = 20 * log10( left / 65536.0F ); + rdB = 20 * log10( right / 65536.0F ); + + set_mixer(output.device, alsa.volume_mixer_name, alsa.volume_mixer_index, false, ldB, rdB); +} + +static void *alsa_error_handler(const char *file, int line, const char *function, int err, const char *fmt, ...) { + va_list args; + if ((loglevel >= lINFO && err == 0) || loglevel >= lDEBUG) { + fprintf(stderr, "%s ALSA %s:%d ", logtime(), function, line); + va_start(args, fmt); + vfprintf(stderr, fmt, args); + fprintf(stderr, "\n"); + fflush(stderr); + } + return NULL; +} + +static void alsa_close(void) { + int err; + if ((err = snd_pcm_close(pcmp)) < 0) { + LOG_INFO("snd_pcm_close error: %s", snd_strerror(err)); + } +} + +bool test_open(const char *device, unsigned rates[]) { + int err; + snd_pcm_t *pcm; + snd_pcm_hw_params_t *hw_params; + hw_params = (snd_pcm_hw_params_t *) alloca(snd_pcm_hw_params_sizeof()); + memset(hw_params, 0, snd_pcm_hw_params_sizeof()); + + // open device + if ((err = snd_pcm_open(&pcm, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) { + LOG_ERROR("playback open error: %s", snd_strerror(err)); + return false; + } + + // get max params + if ((err = snd_pcm_hw_params_any(pcm, hw_params)) < 0) { + LOG_ERROR("hwparam init error: %s", snd_strerror(err)); + return false; + } + + // find supported sample rates to enable client side resampling of non supported rates + unsigned i, ind; + unsigned ref[] TEST_RATES; + + for (i = 0, ind = 0; ref[i]; ++i) { + if (snd_pcm_hw_params_test_rate(pcm, hw_params, ref[i], 0) == 0) { + rates[ind++] = ref[i]; + } + } + + if ((err = snd_pcm_close(pcm)) < 0) { + LOG_ERROR("snd_pcm_close error: %s", snd_strerror(err)); + return false; + } + + return true; +} + +static bool pcm_probe(const char *device) { + int err; + snd_pcm_t *pcm; + + if ((err = snd_pcm_open(&pcm, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) { + return false; + } + + if ((err = snd_pcm_close(pcm)) < 0) { + LOG_ERROR("snd_pcm_close error: %s", snd_strerror(err)); + } + + return true; +} + +static int alsa_open(const char *device, unsigned sample_rate, unsigned alsa_buffer, unsigned alsa_period) { + int err; + snd_pcm_hw_params_t *hw_params; + snd_pcm_hw_params_alloca(&hw_params); + + // close if already open + if (pcmp) alsa_close(); + + // reset params + alsa.rate = 0; + alsa.period_size = 0; + strcpy(alsa.device, device); + + if (strlen(device) > MAX_DEVICE_LEN - 4 - 1) { + LOG_ERROR("device name too long: %s", device); + return -1; + } + + LOG_INFO("opening device at: %u", sample_rate); + + bool retry; + do { + // open device + if ((err = snd_pcm_open(&pcmp, alsa.device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) { + LOG_ERROR("playback open error: %s", snd_strerror(err)); + return err; + } + + // init params + memset(hw_params, 0, snd_pcm_hw_params_sizeof()); + if ((err = snd_pcm_hw_params_any(pcmp, hw_params)) < 0) { + LOG_ERROR("hwparam init error: %s", snd_strerror(err)); + return err; + } + + // open hw: devices without resampling, if sample rate fails try plughw: with resampling + bool hw = !strncmp(alsa.device, "hw:", 3); + retry = false; + + if ((err = snd_pcm_hw_params_set_rate_resample(pcmp, hw_params, !hw)) < 0) { + LOG_ERROR("resampling setup failed: %s", snd_strerror(err)); + return err; + } + + if ((err = snd_pcm_hw_params_set_rate(pcmp, hw_params, sample_rate, 0)) < 0) { + if (hw) { + strcpy(alsa.device + 4, device); + memcpy(alsa.device, "plug", 4); + LOG_INFO("reopening device %s in plug mode as %s for resampling", device, alsa.device); + snd_pcm_close(pcmp); + retry = true; + } + } + + } while (retry); + + // set access + if (!alsa.mmap || snd_pcm_hw_params_set_access(pcmp, hw_params, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0) { + if ((err = snd_pcm_hw_params_set_access(pcmp, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { + LOG_ERROR("access type not available: %s", snd_strerror(err)); + return err; + } + alsa.mmap = false; + } + + // set the sample format + snd_pcm_format_t *fmt = alsa.format ? &alsa.format : (snd_pcm_format_t *)fmts; + do { + if (snd_pcm_hw_params_set_format(pcmp, hw_params, *fmt) >= 0) { + LOG_INFO("opened device %s using format: %s sample rate: %u mmap: %u", alsa.device, snd_pcm_format_name(*fmt), sample_rate, alsa.mmap); + alsa.format = *fmt; + break; + } + if (alsa.format) { + LOG_ERROR("unable to open audio device requested format: %s", snd_pcm_format_name(alsa.format)); + return -1; + } + ++fmt; + if (*fmt == SND_PCM_FORMAT_UNKNOWN) { + LOG_ERROR("unable to open audio device with any supported format"); + return -1; + } + } while (*fmt != SND_PCM_FORMAT_UNKNOWN); + + // set the output format to be used by _scale_and_pack + switch(alsa.format) { + case SND_PCM_FORMAT_S32_LE: + output.format = S32_LE; break; + case SND_PCM_FORMAT_S24_LE: + output.format = S24_LE; break; + case SND_PCM_FORMAT_S24_3LE: + output.format = S24_3LE; break; + case SND_PCM_FORMAT_S16_LE: + output.format = S16_LE; break; + default: + break; + } + + // set channels + if ((err = snd_pcm_hw_params_set_channels (pcmp, hw_params, 2)) < 0) { + LOG_ERROR("channel count not available: %s", snd_strerror(err)); + return err; + } + + // set period size - value of < 50 treated as period count, otherwise size in bytes + if (alsa_period < 50) { + unsigned count = alsa_period; + if ((err = snd_pcm_hw_params_set_periods_near(pcmp, hw_params, &count, 0)) < 0) { + LOG_ERROR("unable to set period count %s", snd_strerror(err)); + return err; + } + } else { + snd_pcm_uframes_t size = alsa_period; + int dir = 0; + if ((err = snd_pcm_hw_params_set_period_size_near(pcmp, hw_params, &size, &dir)) < 0) { + LOG_ERROR("unable to set period size %s", snd_strerror(err)); + return err; + } + } + + // set buffer size - value of < 500 treated as buffer time in ms, otherwise size in bytes + if (alsa_buffer < 500) { + unsigned time = alsa_buffer * 1000; + int dir = 0; + if ((err = snd_pcm_hw_params_set_buffer_time_near(pcmp, hw_params, &time, &dir)) < 0) { + LOG_ERROR("unable to set buffer time %s", snd_strerror(err)); + return err; + } + } else { + snd_pcm_uframes_t size = alsa_buffer; + if ((err = snd_pcm_hw_params_set_buffer_size_near(pcmp, hw_params, &size)) < 0) { + LOG_ERROR("unable to set buffer size %s", snd_strerror(err)); + return err; + } + } + + // get period_size + if ((err = snd_pcm_hw_params_get_period_size(hw_params, &alsa.period_size, 0)) < 0) { + LOG_ERROR("unable to get period size: %s", snd_strerror(err)); + return err; + } + + // get buffer_size + if ((err = snd_pcm_hw_params_get_buffer_size(hw_params, &alsa.buffer_size)) < 0) { + LOG_ERROR("unable to get buffer size: %s", snd_strerror(err)); + return err; + } + + LOG_INFO("buffer: %u period: %u -> buffer size: %u period size: %u", alsa_buffer, alsa_period, alsa.buffer_size, alsa.period_size); + + // ensure we have two buffer sizes of samples before starting output + output.start_frames = alsa.buffer_size * 2; + + // create an intermediate buffer for non mmap case for all but NATIVE_FORMAT + // this is used to pack samples into the output format before calling writei + if (!alsa.mmap && !alsa.write_buf && alsa.format != NATIVE_FORMAT) { + alsa.write_buf = malloc(alsa.buffer_size * BYTES_PER_FRAME); + if (!alsa.write_buf) { + LOG_ERROR("unable to malloc write_buf"); + return -1; + } + } + + // set params + if ((err = snd_pcm_hw_params(pcmp, hw_params)) < 0) { + LOG_ERROR("unable to set hw params: %s", snd_strerror(err)); + return err; + } + + // dump info + if (loglevel == lSDEBUG) { + static snd_output_t *debug_output; + snd_output_stdio_attach(&debug_output, stderr, 0); + snd_pcm_dump(pcmp, debug_output); + } + + // this indicates we have opened the device ok + alsa.rate = sample_rate; + + return 0; +} + +static int _write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR, + s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr) { + + const snd_pcm_channel_area_t *areas; + snd_pcm_uframes_t offset; + void *outputptr; + s32_t *inputptr; + int err; + + if (alsa.mmap) { + snd_pcm_uframes_t alsa_frames = (snd_pcm_uframes_t)out_frames; + + snd_pcm_avail_update(pcmp); + + if ((err = snd_pcm_mmap_begin(pcmp, &areas, &offset, &alsa_frames)) < 0) { + LOG_WARN("error from mmap_begin: %s", snd_strerror(err)); + return -1; + } + + out_frames = (frames_t)alsa_frames; + } + + if (!silence) { + // applying cross fade is delayed until this point as mmap_begin can change out_frames + if (output.fade == FADE_ACTIVE && output.fade_dir == FADE_CROSS && *cross_ptr) { + _apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out, cross_ptr); + } + } + + inputptr = (s32_t *) (silence ? silencebuf : outputbuf->readp); + + IF_DSD( + if (output.dop) { + if (silence) { + inputptr = (s32_t *) silencebuf_dop; + } + update_dop((u32_t *) inputptr, out_frames, output.invert && !silence); + } + ) + + if (alsa.mmap || alsa.format != NATIVE_FORMAT) { + + outputptr = alsa.mmap ? (areas[0].addr + (areas[0].first + offset * areas[0].step) / 8) : alsa.write_buf; + + _scale_and_pack_frames(outputptr, inputptr, out_frames, gainL, gainR, output.format); + + } else { + + outputptr = (void *)inputptr; + + if (!silence) { + + if (gainL != FIXED_ONE || gainR!= FIXED_ONE) { + _apply_gain(outputbuf, out_frames, gainL, gainR); + } + } + } + + if (alsa.mmap) { + + snd_pcm_sframes_t w = snd_pcm_mmap_commit(pcmp, offset, out_frames); + if (w < 0 || w != out_frames) { + LOG_WARN("mmap_commit error"); + return -1; + } + + } else { + + snd_pcm_sframes_t w = snd_pcm_writei(pcmp, outputptr, out_frames); + if (w < 0) { + //if (w != -EAGAIN && ((err = snd_pcm_recover(pcmp, w, 1)) < 0)) { + if (((err = snd_pcm_recover(pcmp, w, 1)) < 0)) { + static unsigned recover_count = 0; + LOG_WARN("recover failed: %s [%u]", snd_strerror(err), ++recover_count); + if (recover_count >= 10) { + recover_count = 0; + alsa_close(); + pcmp = NULL; + } + } + return -1; + } else { + if (w != out_frames) { + LOG_WARN("writei only wrote %u of %u", w, out_frames); + } + out_frames = w; + } + } + + return (int)out_frames; +} + +static void *output_thread(void *arg) { + bool start = true; + bool output_off = (output.state == OUTPUT_OFF); + bool probe_device = (arg != NULL); + int err; + + while (running) { + + // disabled output - player is off + while (output_off) { + usleep(100000); + LOCK; + output_off = (output.state == OUTPUT_OFF); + UNLOCK; + if (!running) return 0; + } + + // wait until device returns - to allow usb audio devices to be turned off + if (probe_device) { + while (!pcm_probe(output.device)) { + LOG_DEBUG("waiting for device %s to return", output.device); + sleep(5); + } + probe_device = false; + } + + if (!pcmp || alsa.rate != output.current_sample_rate) { + LOG_INFO("open output device: %s", output.device); + LOCK; + + // FIXME - some alsa hardware requires opening twice for a new sample rate to work + // this is a workaround which should be removed + if (alsa.reopen) { + alsa_open(output.device, output.current_sample_rate, output.buffer, output.period); + } + + if (!!alsa_open(output.device, output.current_sample_rate, output.buffer, output.period)) { + output.error_opening = true; + UNLOCK; + sleep(5); + continue; + } + output.error_opening = false; + start = true; + UNLOCK; + } + + snd_pcm_state_t state = snd_pcm_state(pcmp); + + if (state == SND_PCM_STATE_XRUN) { + LOG_INFO("XRUN"); + if ((err = snd_pcm_recover(pcmp, -EPIPE, 1)) < 0) { + LOG_INFO("XRUN recover failed: %s", snd_strerror(err)); + } + start = true; + continue; + } else if (state == SND_PCM_STATE_SUSPENDED) { + if ((err = snd_pcm_recover(pcmp, -ESTRPIPE, 1)) < 0) { + LOG_INFO("SUSPEND recover failed: %s", snd_strerror(err)); + } + } else if (state == SND_PCM_STATE_DISCONNECTED) { + LOG_INFO("Device %s no longer available", output.device); + alsa_close(); + pcmp = NULL; + probe_device = true; + continue; + } + + snd_pcm_sframes_t avail = snd_pcm_avail_update(pcmp); + + if (avail < 0) { + if ((err = snd_pcm_recover(pcmp, avail, 1)) < 0) { + if (err == -ENODEV) { + LOG_INFO("Device %s no longer available", output.device); + alsa_close(); + pcmp = NULL; + probe_device = true; + continue; + } + LOG_WARN("recover failed: %s", snd_strerror(err)); + } + start = true; + continue; + } + + if (avail < alsa.period_size) { + if (start) { + if (alsa.mmap && ((err = snd_pcm_start(pcmp)) < 0)) { + if ((err = snd_pcm_recover(pcmp, err, 1)) < 0) { + if (err == -ENODEV) { + LOG_INFO("Device %s no longer available", output.device); + alsa_close(); + pcmp = NULL; + probe_device = true; + continue; + } + LOG_INFO("start error: %s", snd_strerror(err)); + usleep(10000); + } + } else { + start = false; + } + } else { + if ((err = snd_pcm_wait(pcmp, 1000)) < 0) { + if ((err = snd_pcm_recover(pcmp, err, 1)) < 0) { + LOG_INFO("pcm wait error: %s", snd_strerror(err)); + } + start = true; + } + } + continue; + } + + // restrict avail to within sensible limits as alsa drivers can return erroneous large values + // in writei mode restrict to period_size due to size of write_buf + if (alsa.mmap) { + avail = min(avail, alsa.buffer_size); + } else { + avail = min(avail, alsa.period_size); + } + + // avoid spinning in cases where wait returns but no bytes available (seen with pulse audio) + if (avail == 0) { + LOG_SDEBUG("avail 0 - sleeping"); + usleep(10000); + continue; + } + + LOCK; + + // turn off if requested + if (output.state == OUTPUT_OFF) { + UNLOCK; + LOG_INFO("disabling output"); + alsa_close(); + pcmp = NULL; + output_off = true; + vis_stop(); + continue; + } + + // measure output delay + snd_pcm_sframes_t delay; + if ((err = snd_pcm_delay(pcmp, &delay)) < 0) { + if (err == -EPIPE) { + // EPIPE indicates underrun - attempt to recover + UNLOCK; + continue; + } else if (err == -EIO) { + // EIO can occur with non existant pulse server + UNLOCK; + LOG_SDEBUG("snd_pcm_delay returns: EIO - sleeping"); + usleep(100000); + continue; + } else { + LOG_DEBUG("snd_pcm_delay returns: %d", err); + } + } else { + output.device_frames = delay; + output.updated = gettime_ms(); + output.frames_played_dmp = output.frames_played; + } + + // process frames + frames_t wrote = _output_frames(avail); + + UNLOCK; + + // some output devices such as alsa null refuse any data, avoid spinning + if (!wrote) { + LOG_SDEBUG("wrote 0 - sleeping"); + usleep(10000); + } + } + + return 0; +} + +static pthread_t thread; + +void output_init_alsa(log_level level, const char *device, unsigned output_buf_size, char *params, unsigned rates[], + unsigned rate_delay, unsigned rt_priority, unsigned idle, char *volume_mixer, bool mixer_unmute) { + + unsigned alsa_buffer = ALSA_BUFFER_TIME; + unsigned alsa_period = ALSA_PERIOD_COUNT; + char *alsa_sample_fmt = NULL; + bool alsa_mmap = true; + bool alsa_reopen = false; + + char *volume_mixer_name = next_param(volume_mixer, ','); + char *volume_mixer_index = next_param(NULL, ','); + + char *t = next_param(params, ':'); + char *c = next_param(NULL, ':'); + char *s = next_param(NULL, ':'); + char *m = next_param(NULL, ':'); + char *r = next_param(NULL, ':'); + + if (t) alsa_buffer = atoi(t); + if (c) alsa_period = atoi(c); + if (s) alsa_sample_fmt = s; + if (m) alsa_mmap = atoi(m); + if (r) alsa_reopen = atoi(r); + + loglevel = level; + + LOG_INFO("init output"); + + memset(&output, 0, sizeof(output)); + + alsa.mmap = alsa_mmap; + alsa.write_buf = NULL; + alsa.format = 0; + alsa.reopen = alsa_reopen; + + if (!mixer_unmute) { + alsa.volume_mixer_name = volume_mixer_name; + alsa.volume_mixer_index = volume_mixer_index ? atoi(volume_mixer_index) : 0; + } + + output.format = 0; + output.buffer = alsa_buffer; + output.period = alsa_period; + output.start_frames = 0; + output.write_cb = &_write_frames; + output.rate_delay = rate_delay; + + if (alsa_sample_fmt) { + if (!strcmp(alsa_sample_fmt, "32")) alsa.format = SND_PCM_FORMAT_S32_LE; + if (!strcmp(alsa_sample_fmt, "24")) alsa.format = SND_PCM_FORMAT_S24_LE; + if (!strcmp(alsa_sample_fmt, "24_3")) alsa.format = SND_PCM_FORMAT_S24_3LE; + if (!strcmp(alsa_sample_fmt, "16")) alsa.format = SND_PCM_FORMAT_S16_LE; + } + + LOG_INFO("requested alsa_buffer: %u alsa_period: %u format: %s mmap: %u", output.buffer, output.period, + alsa_sample_fmt ? alsa_sample_fmt : "any", alsa.mmap); + + snd_lib_error_set_handler((snd_lib_error_handler_t)alsa_error_handler); + + output_init_common(level, device, output_buf_size, rates, idle); + + if (mixer_unmute && volume_mixer_name) { + set_mixer(output.device, volume_mixer_name, volume_mixer_index ? atoi(volume_mixer_index) : 0, true, 0, 0); + } + +#if LINUX + // RT linux - aim to avoid pagefaults by locking memory: + // https://rt.wiki.kernel.org/index.php/Threaded_RT-application_with_memory_locking_and_stack_handling_example + if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) { + LOG_INFO("unable to lock memory: %s", strerror(errno)); + } else { + LOG_INFO("memory locked"); + } + + mallopt(M_TRIM_THRESHOLD, -1); + mallopt(M_MMAP_MAX, 0); + + touch_memory(silencebuf, MAX_SILENCE_FRAMES * BYTES_PER_FRAME); + touch_memory(outputbuf->buf, outputbuf->size); +#endif + + // start output thread + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN + OUTPUT_THREAD_STACK_SIZE); + pthread_create(&thread, &attr, output_thread, rates[0] ? "probe" : NULL); + pthread_attr_destroy(&attr); + + // try to set this thread to real-time scheduler class, only works as root or if user has permission + struct sched_param param; + param.sched_priority = rt_priority; + if (pthread_setschedparam(thread, SCHED_FIFO, ¶m) != 0) { + LOG_DEBUG("unable to set output sched fifo: %s", strerror(errno)); + } else { + LOG_DEBUG("set output sched fifo rt: %u", param.sched_priority); + } +} + +void output_close_alsa(void) { + LOG_INFO("close output"); + + LOCK; + running = false; + UNLOCK; + + pthread_join(thread, NULL); + + if (alsa.write_buf) free(alsa.write_buf); + + output_close_common(); +} + +#endif // ALSA + diff --git a/output_pa.c b/output_pa.c new file mode 100644 index 0000000..025904b --- /dev/null +++ b/output_pa.c @@ -0,0 +1,455 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// Portaudio output + +#include "squeezelite.h" + +#if PORTAUDIO + +#include +#if OSX +#include +#endif + +// ouput device +static struct { + unsigned rate; + PaStream *stream; +} pa; + +static log_level loglevel; + +static bool running = true; + +extern struct outputstate output; +extern struct buffer *outputbuf; + +#define LOCK mutex_lock(outputbuf->mutex) +#define UNLOCK mutex_unlock(outputbuf->mutex) + +extern u8_t *silencebuf; +#if DSD +extern u8_t *silencebuf_dop; +#endif + +void list_devices(void) { + PaError err; + int i; + + if ((err = Pa_Initialize()) != paNoError) { + LOG_WARN("error initialising port audio: %s", Pa_GetErrorText(err)); + return; + } + + printf("Output devices:\n"); + for (i = 0; i < Pa_GetDeviceCount(); ++i) { + if (Pa_GetDeviceInfo(i)->maxOutputChannels) { + printf(" %i - %s [%s]\n", i, Pa_GetDeviceInfo(i)->name, Pa_GetHostApiInfo(Pa_GetDeviceInfo(i)->hostApi)->name); + } + } + printf("\n"); + + if ((err = Pa_Terminate()) != paNoError) { + LOG_WARN("error closing port audio: %s", Pa_GetErrorText(err)); + } +} + +void set_volume(unsigned left, unsigned right) { + LOG_DEBUG("setting internal gain left: %u right: %u", left, right); + LOCK; + output.gainL = left; + output.gainR = right; + UNLOCK; +} + +static int pa_device_id(const char *device) { + int len = strlen(device); + int i; + + if (!strncmp(device, "default", 7)) { + return Pa_GetDefaultOutputDevice(); + } + if (len >= 1 && len <= 2 && device[0] >= '0' && device[0] <= '9') { + return atoi(device); + } + +#define DEVICE_ID_MAXLEN 256 + for (i = 0; i < Pa_GetDeviceCount(); ++i) { + char tmp[DEVICE_ID_MAXLEN]; + snprintf(tmp, DEVICE_ID_MAXLEN, "%s [%s]", Pa_GetDeviceInfo(i)->name, Pa_GetHostApiInfo(Pa_GetDeviceInfo(i)->hostApi)->name); + if (!strncmp(tmp, device, len)) { + return i; + } + } + + return -1; +} + +static int pa_callback(const void *pa_input, void *pa_output, unsigned long pa_frames_wanted, + const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData); + +bool test_open(const char *device, unsigned rates[]) { + PaStreamParameters outputParameters; + PaError err; + unsigned ref[] TEST_RATES; + int device_id, i, ind; + + if ((device_id = pa_device_id(device)) == -1) { + LOG_INFO("device %s not found", device); + return false; + } + + outputParameters.device = device_id; + outputParameters.channelCount = 2; + outputParameters.sampleFormat = paInt32; + outputParameters.suggestedLatency = + output.latency ? (double)output.latency/(double)1000 : Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency; + outputParameters.hostApiSpecificStreamInfo = NULL; + + // check supported sample rates + // Note use Pa_OpenStream as it appears more reliable than Pa_IsFormatSupported on some windows apis + for (i = 0, ind = 0; ref[i]; ++i) { + err = Pa_OpenStream(&pa.stream, NULL, &outputParameters, (double)ref[i], paFramesPerBufferUnspecified, paNoFlag, + pa_callback, NULL); + if (err == paNoError) { + Pa_CloseStream(pa.stream); + rates[ind++] = ref[i]; + } + } + + if (!rates[0]) { + LOG_WARN("no available rate found"); + return false; + } + + pa.stream = NULL; + return true; +} + +static void pa_stream_finished(void *userdata) { + if (running) { + LOG_INFO("stream finished"); + LOCK; + output.pa_reopen = true; + wake_controller(); + UNLOCK; + } +} + +static thread_type monitor_thread; +bool monitor_thread_running = false; + +static void *pa_monitor() { + bool output_off; + + LOCK; + + if (monitor_thread_running) { + LOG_DEBUG("monitor thread already running"); + UNLOCK; + return 0; + } + + LOG_DEBUG("start monitor thread"); + + monitor_thread_running = true; + output_off = (output.state == OUTPUT_OFF); + + while (monitor_thread_running) { + if (output_off) { + if (output.state != OUTPUT_OFF) { + LOG_INFO("output on"); + break; + } + } else { + // this is a hack to partially support hot plugging of devices + // we rely on terminating and reinitalising PA to get an updated list of devices and use name for output.device + LOG_INFO("probing device %s", output.device); + Pa_Terminate(); + Pa_Initialize(); + pa.stream = NULL; + if (pa_device_id(output.device) != -1) { + LOG_INFO("device reopen"); + break; + } + } + + UNLOCK; + sleep(output_off ? 1 : 5); + LOCK; + } + + LOG_DEBUG("end monitor thread"); + + monitor_thread_running = false; + pa.stream = NULL; + + _pa_open(); + + UNLOCK; + + return 0; +} + +void _pa_open(void) { + PaStreamParameters outputParameters; + PaError err = paNoError; + int device_id; + + if (pa.stream) { + if ((err = Pa_CloseStream(pa.stream)) != paNoError) { + LOG_WARN("error closing stream: %s", Pa_GetErrorText(err)); + } + } + + if (output.state == OUTPUT_OFF) { + // we get called when transitioning to OUTPUT_OFF to create the probe thread + // set err to avoid opening device and logging messages + err = 1; + + } else if ((device_id = pa_device_id(output.device)) == -1) { + LOG_INFO("device %s not found", output.device); + err = 1; + + } else { + + outputParameters.device = device_id; + outputParameters.channelCount = 2; + outputParameters.sampleFormat = paInt32; + outputParameters.suggestedLatency = + output.latency ? (double)output.latency/(double)1000 : Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency; + outputParameters.hostApiSpecificStreamInfo = NULL; + +#if OSX + // enable pro mode which aims to avoid resampling if possible + // see http://code.google.com/p/squeezelite/issues/detail?id=11 & http://code.google.com/p/squeezelite/issues/detail?id=37 + // command line controls osx_playnice which is -1 if not specified, 0 or 1 - choose playnice if -1 or 1 + PaMacCoreStreamInfo macInfo; + unsigned long streamInfoFlags; + if (output.osx_playnice) { + LOG_INFO("opening device in PlayNice mode"); + streamInfoFlags = paMacCorePlayNice; + } else { + LOG_INFO("opening device in Pro mode"); + streamInfoFlags = paMacCorePro; + } + PaMacCore_SetupStreamInfo(&macInfo, streamInfoFlags); + outputParameters.hostApiSpecificStreamInfo = &macInfo; +#endif + } + + if (!err && + (err = Pa_OpenStream(&pa.stream, NULL, &outputParameters, (double)output.current_sample_rate, paFramesPerBufferUnspecified, + paPrimeOutputBuffersUsingStreamCallback | paDitherOff, pa_callback, NULL)) != paNoError) { + LOG_WARN("error opening device %i - %s : %s", outputParameters.device, Pa_GetDeviceInfo(outputParameters.device)->name, + Pa_GetErrorText(err)); + } + + if (!err) { + LOG_INFO("opened device %i - %s at %u latency %u ms", outputParameters.device, Pa_GetDeviceInfo(outputParameters.device)->name, + (unsigned int)Pa_GetStreamInfo(pa.stream)->sampleRate, (unsigned int)(Pa_GetStreamInfo(pa.stream)->outputLatency * 1000)); + + pa.rate = output.current_sample_rate; + + if ((err = Pa_SetStreamFinishedCallback(pa.stream, pa_stream_finished)) != paNoError) { + LOG_WARN("error setting finish callback: %s", Pa_GetErrorText(err)); + } + + UNLOCK; // StartStream can call pa_callback in a sychronised thread on freebsd, remove lock while it is called + + if ((err = Pa_StartStream(pa.stream)) != paNoError) { + LOG_WARN("error starting stream: %s", Pa_GetErrorText(err)); + } + + LOCK; + } + + if (err && !monitor_thread_running) { + vis_stop(); + + // create a thread to check for output state change or device return +#if LINUX || OSX || FREEBSD + pthread_create(&monitor_thread, NULL, pa_monitor, NULL); +#endif +#if WIN + monitor_thread = CreateThread(NULL, OUTPUT_THREAD_STACK_SIZE, (LPTHREAD_START_ROUTINE)&pa_monitor, NULL, 0, NULL); +#endif + } + + output.error_opening = !!err; +} + +static u8_t *optr; + +static int _write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR, + s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr) { + + if (!silence) { + + if (output.fade == FADE_ACTIVE && output.fade_dir == FADE_CROSS && *cross_ptr) { + _apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out, cross_ptr); + } + + if (gainL != FIXED_ONE || gainR!= FIXED_ONE) { + _apply_gain(outputbuf, out_frames, gainL, gainR); + } + + IF_DSD( + if (output.dop) { + update_dop((u32_t *) outputbuf->readp, out_frames, output.invert); + } + ) + + memcpy(optr, outputbuf->readp, out_frames * BYTES_PER_FRAME); + + } else { + + u8_t *buf = silencebuf; + + IF_DSD( + if (output.dop) { + buf = silencebuf_dop; + update_dop((u32_t *) buf, out_frames, false); // don't invert silence + } + ) + + memcpy(optr, buf, out_frames * BYTES_PER_FRAME); + } + + optr += out_frames * BYTES_PER_FRAME; + + return (int)out_frames; +} + +static int pa_callback(const void *pa_input, void *pa_output, unsigned long pa_frames_wanted, + const PaStreamCallbackTimeInfo *time_info, PaStreamCallbackFlags statusFlags, void *userData) { + int ret; + double stream_time; + frames_t frames; + + optr = (u8_t *)pa_output; + + LOCK; + + stream_time = Pa_GetStreamTime(pa.stream); + + if (time_info->outputBufferDacTime > stream_time) { + // workaround for wdm-ks which can return outputBufferDacTime with a different epoch + output.device_frames = (unsigned)((time_info->outputBufferDacTime - stream_time) * output.current_sample_rate); + } else { + output.device_frames = 0; + } + + output.updated = gettime_ms(); + output.frames_played_dmp = output.frames_played; + + do { + frames = _output_frames(pa_frames_wanted); + pa_frames_wanted -= frames; + } while (pa_frames_wanted > 0 && frames != 0); + + if (pa_frames_wanted > 0) { + LOG_DEBUG("pad with silence"); + memset(optr, 0, pa_frames_wanted * BYTES_PER_FRAME); + } + + if (output.state == OUTPUT_OFF) { + LOG_INFO("output off"); + ret = paComplete; + } else if (pa.rate != output.current_sample_rate) { + ret = paComplete; + } else { + ret = paContinue; + } + + UNLOCK; + + return ret; +} + +void output_init_pa(log_level level, const char *device, unsigned output_buf_size, char *params, unsigned rates[], unsigned rate_delay, + unsigned idle) { + PaError err; + unsigned latency = 0; + int osx_playnice = -1; + + char *l = next_param(params, ':'); + char *p = next_param(NULL, ':'); + + if (l) latency = (unsigned)atoi(l); + if (p) osx_playnice = atoi(p); + + loglevel = level; + + LOG_INFO("init output"); + + memset(&output, 0, sizeof(output)); + + output.latency = latency; + output.osx_playnice = osx_playnice; + output.format = 0; + output.start_frames = 0; + output.write_cb = &_write_frames; + output.rate_delay = rate_delay; + pa.stream = NULL; + + LOG_INFO("requested latency: %u", output.latency); + + if ((err = Pa_Initialize()) != paNoError) { + LOG_WARN("error initialising port audio: %s", Pa_GetErrorText(err)); + exit(0); + } + + output_init_common(level, device, output_buf_size, rates, idle); + + LOCK; + + _pa_open(); + + UNLOCK; +} + +void output_close_pa(void) { + PaError err; + + LOG_INFO("close output"); + + LOCK; + + running = false; + monitor_thread_running = false; + + if (pa.stream) { + if ((err = Pa_AbortStream(pa.stream)) != paNoError) { + LOG_WARN("error closing stream: %s", Pa_GetErrorText(err)); + } + } + + if ((err = Pa_Terminate()) != paNoError) { + LOG_WARN("error closing port audio: %s", Pa_GetErrorText(err)); + } + + UNLOCK; + + output_close_common(); +} + +#endif // PORTAUDIO diff --git a/output_pack.c b/output_pack.c new file mode 100644 index 0000000..16e7ab7 --- /dev/null +++ b/output_pack.c @@ -0,0 +1,270 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// Scale and pack functions + +#include "squeezelite.h" + +#define MAX_SCALESAMPLE 0x7fffffffffffLL +#define MIN_SCALESAMPLE -MAX_SCALESAMPLE + +// inlining these on windows prevents them being linkable... +#if !WIN +inline +#endif +s32_t gain(s32_t gain, s32_t sample) { + s64_t res = (s64_t)gain * (s64_t)sample; + if (res > MAX_SCALESAMPLE) res = MAX_SCALESAMPLE; + if (res < MIN_SCALESAMPLE) res = MIN_SCALESAMPLE; + return (s32_t) (res >> 16); +} +#if !WIN +inline +#endif +s32_t to_gain(float f) { + return (s32_t)(f * 65536.0F); +} + +void _scale_and_pack_frames(void *outputptr, s32_t *inputptr, frames_t cnt, s32_t gainL, s32_t gainR, output_format format) { + switch(format) { + case S16_LE: + { + u32_t *optr = (u32_t *)(void *)outputptr; +#if SL_LITTLE_ENDIAN + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + while (cnt--) { + *(optr++) = (*(inputptr) >> 16 & 0x0000ffff) | (*(inputptr + 1) & 0xffff0000); + inputptr += 2; + } + } else { + while (cnt--) { + *(optr++) = (gain(gainL, *(inputptr)) >> 16 & 0x0000ffff) | (gain(gainR, *(inputptr+1)) & 0xffff0000); + inputptr += 2; + } + } +#else + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + while (cnt--) { + s32_t lsample = *(inputptr++); + s32_t rsample = *(inputptr++); + *(optr++) = + (lsample & 0x00ff0000) << 8 | (lsample & 0xff000000) >> 8 | + (rsample & 0x00ff0000) >> 8 | (rsample & 0xff000000) >> 24; + } + } else { + while (cnt--) { + s32_t lsample = gain(gainL, *(inputptr++)); + s32_t rsample = gain(gainR, *(inputptr++)); + *(optr++) = + (lsample & 0x00ff0000) << 8 | (lsample & 0xff000000) >> 8 | + (rsample & 0x00ff0000) >> 8 | (rsample & 0xff000000) >> 24; + } + } +#endif + } + break; + case S24_LE: + { + u32_t *optr = (u32_t *)(void *)outputptr; +#if SL_LITTLE_ENDIAN + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + while (cnt--) { + *(optr++) = *(inputptr++) >> 8; + *(optr++) = *(inputptr++) >> 8; + } + } else { + while (cnt--) { + *(optr++) = gain(gainL, *(inputptr++)) >> 8; + *(optr++) = gain(gainR, *(inputptr++)) >> 8; + } + } +#else + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + while (cnt--) { + s32_t lsample = *(inputptr++); + s32_t rsample = *(inputptr++); + *(optr++) = + (lsample & 0xff000000) >> 16 | (lsample & 0x00ff0000) | (lsample & 0x0000ff00 << 16); + *(optr++) = + (rsample & 0xff000000) >> 16 | (rsample & 0x00ff0000) | (rsample & 0x0000ff00 << 16); + } + } else { + while (cnt--) { + s32_t lsample = gain(gainL, *(inputptr++)); + s32_t rsample = gain(gainR, *(inputptr++)); + *(optr++) = + (lsample & 0xff000000) >> 16 | (lsample & 0x00ff0000) | (lsample & 0x0000ff00 << 16); + *(optr++) = + (rsample & 0xff000000) >> 16 | (rsample & 0x00ff0000) | (rsample & 0x0000ff00 << 16); + } + } +#endif + } + break; + case S24_3LE: + { + u8_t *optr = (u8_t *)(void *)outputptr; + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + while (cnt) { + // attempt to do 32 bit memory accesses - move 2 frames at once: 16 bytes -> 12 bytes + // falls through to exception case when not aligned or if less than 2 frames to move + if (((uintptr_t)optr & 0x3) == 0 && cnt >= 2) { + u32_t *o_ptr = (u32_t *)(void *)optr; + while (cnt >= 2) { + s32_t l1 = *(inputptr++); s32_t r1 = *(inputptr++); + s32_t l2 = *(inputptr++); s32_t r2 = *(inputptr++); +#if SL_LITTLE_ENDIAN + *(o_ptr++) = (l1 & 0xffffff00) >> 8 | (r1 & 0x0000ff00) << 16; + *(o_ptr++) = (r1 & 0xffff0000) >> 16 | (l2 & 0x00ffff00) << 8; + *(o_ptr++) = (l2 & 0xff000000) >> 24 | (r2 & 0xffffff00); +#else + *(o_ptr++) = (l1 & 0x0000ff00) << 16 | (l1 & 0x00ff0000) | (l1 & 0xff000000) >> 16 | + (r1 & 0x0000ff00) >> 8; + *(o_ptr++) = (r1 & 0x00ff0000) << 8 | (r1 & 0xff000000) >> 8 | (l2 & 0x0000ff00) | + (l2 & 0x00ff0000) >> 16; + *(o_ptr++) = (l2 & 0xff000000) | (r2 & 0x0000ff00) << 8 | (r2 & 0x00ff0000) >> 8 | + (r2 & 0xff000000) >> 24; +#endif + optr += 12; + cnt -= 2; + } + } else { + s32_t lsample = *(inputptr++); + s32_t rsample = *(inputptr++); + *(optr++) = (lsample & 0x0000ff00) >> 8; + *(optr++) = (lsample & 0x00ff0000) >> 16; + *(optr++) = (lsample & 0xff000000) >> 24; + *(optr++) = (rsample & 0x0000ff00) >> 8; + *(optr++) = (rsample & 0x00ff0000) >> 16; + *(optr++) = (rsample & 0xff000000) >> 24; + cnt--; + } + } + } else { + while (cnt) { + // attempt to do 32 bit memory accesses - move 2 frames at once: 16 bytes -> 12 bytes + // falls through to exception case when not aligned or if less than 2 frames to move + if (((uintptr_t)optr & 0x3) == 0 && cnt >= 2) { + u32_t *o_ptr = (u32_t *)(void *)optr; + while (cnt >= 2) { + s32_t l1 = gain(gainL, *(inputptr++)); s32_t r1 = gain(gainR, *(inputptr++)); + s32_t l2 = gain(gainL, *(inputptr++)); s32_t r2 = gain(gainR, *(inputptr++)); +#if SL_LITTLE_ENDIAN + *(o_ptr++) = (l1 & 0xffffff00) >> 8 | (r1 & 0x0000ff00) << 16; + *(o_ptr++) = (r1 & 0xffff0000) >> 16 | (l2 & 0x00ffff00) << 8; + *(o_ptr++) = (l2 & 0xff000000) >> 24 | (r2 & 0xffffff00); +#else + *(o_ptr++) = (l1 & 0x0000ff00) << 16 | (l1 & 0x00ff0000) | (l1 & 0xff000000) >> 16 | + (r1 & 0x0000ff00) >> 8; + *(o_ptr++) = (r1 & 0x00ff0000) << 8 | (r1 & 0xff000000) >> 8 | (l2 & 0x0000ff00) | + (l2 & 0x00ff0000) >> 16; + *(o_ptr++) = (l2 & 0xff000000) | (r2 & 0x0000ff00) << 8 | (r2 & 0x00ff0000) >> 8 | + (r2 & 0xff000000) >> 24; +#endif + optr += 12; + cnt -= 2; + } + } else { + s32_t lsample = gain(gainL, *(inputptr++)); + s32_t rsample = gain(gainR, *(inputptr++)); + *(optr++) = (lsample & 0x0000ff00) >> 8; + *(optr++) = (lsample & 0x00ff0000) >> 16; + *(optr++) = (lsample & 0xff000000) >> 24; + *(optr++) = (rsample & 0x0000ff00) >> 8; + *(optr++) = (rsample & 0x00ff0000) >> 16; + *(optr++) = (rsample & 0xff000000) >> 24; + cnt--; + } + } + } + } + break; + case S32_LE: + { + u32_t *optr = (u32_t *)(void *)outputptr; +#if SL_LITTLE_ENDIAN + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + memcpy(outputptr, inputptr, cnt * BYTES_PER_FRAME); + } else { + while (cnt--) { + *(optr++) = gain(gainL, *(inputptr++)); + *(optr++) = gain(gainR, *(inputptr++)); + } + } +#else + if (gainL == FIXED_ONE && gainR == FIXED_ONE) { + while (cnt--) { + s32_t lsample = *(inputptr++); + s32_t rsample = *(inputptr++); + *(optr++) = + (lsample & 0xff000000) >> 24 | (lsample & 0x00ff0000) >> 8 | + (lsample & 0x0000ff00) << 8 | (lsample & 0x000000ff) << 24; + *(optr++) = + (rsample & 0xff000000) >> 24 | (rsample & 0x00ff0000) >> 8 | + (rsample & 0x0000ff00) << 8 | (rsample & 0x000000ff) << 24; + } + } else { + while (cnt--) { + s32_t lsample = gain(gainL, *(inputptr++)); + s32_t rsample = gain(gainR, *(inputptr++)); + *(optr++) = + (lsample & 0xff000000) >> 24 | (lsample & 0x00ff0000) >> 8 | + (lsample & 0x0000ff00) << 8 | (lsample & 0x000000ff) << 24; + *(optr++) = + (rsample & 0xff000000) >> 24 | (rsample & 0x00ff0000) >> 8 | + (rsample & 0x0000ff00) << 8 | (rsample & 0x000000ff) << 24; + } + } +#endif + } + break; + default: + break; + } +} + +#if !WIN +inline +#endif +void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr) { + s32_t *ptr = (s32_t *)(void *)outputbuf->readp; + frames_t count = out_frames * 2; + while (count--) { + if (*cross_ptr > (s32_t *)outputbuf->wrap) { + *cross_ptr -= outputbuf->size / BYTES_PER_FRAME * 2; + } + *ptr = gain(cross_gain_out, *ptr) + gain(cross_gain_in, **cross_ptr); + ptr++; (*cross_ptr)++; + } +} + +#if !WIN +inline +#endif +void _apply_gain(struct buffer *outputbuf, frames_t count, s32_t gainL, s32_t gainR) { + s32_t *ptrL = (s32_t *)(void *)outputbuf->readp; + s32_t *ptrR = (s32_t *)(void *)outputbuf->readp + 1; + while (count--) { + *ptrL = gain(gainL, *ptrL); + *ptrR = gain(gainR, *ptrR); + ptrL += 2; + ptrR += 2; + } +} diff --git a/output_stdout.c b/output_stdout.c new file mode 100644 index 0000000..37544ab --- /dev/null +++ b/output_stdout.c @@ -0,0 +1,177 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// Stdout output + +#include "squeezelite.h" + +#define FRAME_BLOCK MAX_SILENCE_FRAMES + +static log_level loglevel; + +static bool running = true; + +extern struct outputstate output; +extern struct buffer *outputbuf; + +#define LOCK mutex_lock(outputbuf->mutex) +#define UNLOCK mutex_unlock(outputbuf->mutex) + +extern u8_t *silencebuf; +#if DSD +extern u8_t *silencebuf_dop; +#endif + +// buffer to hold output data so we can block on writing outside of output lock, allocated on init +static u8_t *buf; +static unsigned buffill; +static int bytes_per_frame; + +static int _stdout_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR, + s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr) { + + u8_t *obuf; + + if (!silence) { + + if (output.fade == FADE_ACTIVE && output.fade_dir == FADE_CROSS && *cross_ptr) { + _apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out, cross_ptr); + } + + obuf = outputbuf->readp; + + } else { + + obuf = silencebuf; + } + + IF_DSD( + if (output.dop) { + if (silence) { + obuf = silencebuf_dop; + } + update_dop((u32_t *)obuf, out_frames, output.invert && !silence); + } + ) + + _scale_and_pack_frames(buf + buffill * bytes_per_frame, (s32_t *)(void *)obuf, out_frames, gainL, gainR, output.format); + + buffill += out_frames; + + return (int)out_frames; +} + +static void *output_thread() { + + LOCK; + + switch (output.format) { + case S32_LE: + bytes_per_frame = 4 * 2; break; + case S24_3LE: + bytes_per_frame = 3 * 2; break; + case S16_LE: + bytes_per_frame = 2 * 2; break; + default: + bytes_per_frame = 4 * 2; break; + break; + } + + UNLOCK; + + while (running) { + + LOCK; + + output.device_frames = 0; + output.updated = gettime_ms(); + output.frames_played_dmp = output.frames_played; + + _output_frames(FRAME_BLOCK); + + UNLOCK; + + if (buffill) { + fwrite(buf, bytes_per_frame, buffill, stdout); + buffill = 0; + } + + } + + return 0; +} + +static thread_type thread; + +void output_init_stdout(log_level level, unsigned output_buf_size, char *params, unsigned rates[], unsigned rate_delay) { + loglevel = level; + + LOG_INFO("init output stdout"); + + buf = malloc(FRAME_BLOCK * BYTES_PER_FRAME); + if (!buf) { + LOG_ERROR("unable to malloc buf"); + return; + } + buffill = 0; + + memset(&output, 0, sizeof(output)); + + output.format = S32_LE; + output.start_frames = FRAME_BLOCK * 2; + output.write_cb = &_stdout_write_frames; + output.rate_delay = rate_delay; + + if (params) { + if (!strcmp(params, "32")) output.format = S32_LE; + if (!strcmp(params, "24")) output.format = S24_3LE; + if (!strcmp(params, "16")) output.format = S16_LE; + } + + // ensure output rate is specified to avoid test open + if (!rates[0]) { + rates[0] = 44100; + } + + output_init_common(level, "-", output_buf_size, rates, 0); + +#if LINUX || OSX || FREEBSD + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN + OUTPUT_THREAD_STACK_SIZE); + pthread_create(&thread, &attr, output_thread, NULL); + pthread_attr_destroy(&attr); +#endif +#if WIN + thread = CreateThread(NULL, OUTPUT_THREAD_STACK_SIZE, (LPTHREAD_START_ROUTINE)&output_thread, NULL, 0, NULL); +#endif +} + +void output_close_stdout(void) { + LOG_INFO("close output"); + + LOCK; + running = false; + UNLOCK; + + free(buf); + + output_close_common(); +} diff --git a/output_vis.c b/output_vis.c new file mode 100644 index 0000000..087836e --- /dev/null +++ b/output_vis.c @@ -0,0 +1,144 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// Export audio samples for visualiser process (16 bit only best endevours) + +#include "squeezelite.h" + +#if VISEXPORT + +#include +#include +#include + +#define VIS_BUF_SIZE 16384 +#define VIS_LOCK_NS 1000000 // ns to wait for vis wrlock + +static struct vis_t { + pthread_rwlock_t rwlock; + u32_t buf_size; + u32_t buf_index; + bool running; + u32_t rate; + time_t updated; + s16_t buffer[VIS_BUF_SIZE]; +} *vis_mmap = NULL; + +static char vis_shm_path[40]; +static int vis_fd = -1; + +static log_level loglevel; + +// attempt to write audio to vis_mmap but do not wait more than VIS_LOCK_NS to get wrlock +// this can result in missing audio export to the mmap region, but this is preferable dropping audio +void _vis_export(struct buffer *outputbuf, struct outputstate *output, frames_t out_frames, bool silence) { + if (vis_mmap) { + int err; + + err = pthread_rwlock_trywrlock(&vis_mmap->rwlock); + if (err) { + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + ts.tv_nsec += VIS_LOCK_NS; + if (ts.tv_nsec > 1000000000) { + ts.tv_sec += 1; + ts.tv_nsec -= 1000000000; + } + err = pthread_rwlock_timedwrlock(&vis_mmap->rwlock, &ts); + } + + if (err) { + LOG_DEBUG("failed to get wrlock - skipping visulizer export"); + + } else { + + if (silence) { + vis_mmap->running = false; + } else { + frames_t vis_cnt = out_frames; + s32_t *ptr = (s32_t *) outputbuf->readp; + unsigned i = vis_mmap->buf_index; + + if (!output->current_replay_gain) { + while (vis_cnt--) { + vis_mmap->buffer[i++] = *(ptr++) >> 16; + vis_mmap->buffer[i++] = *(ptr++) >> 16; + if (i == VIS_BUF_SIZE) i = 0; + } + } else { + while (vis_cnt--) { + vis_mmap->buffer[i++] = gain(*(ptr++), output->current_replay_gain) >> 16; + vis_mmap->buffer[i++] = gain(*(ptr++), output->current_replay_gain) >> 16; + if (i == VIS_BUF_SIZE) i = 0; + } + } + + vis_mmap->updated = time(NULL); + vis_mmap->running = true; + vis_mmap->buf_index = i; + vis_mmap->rate = output->current_sample_rate; + } + + pthread_rwlock_unlock(&vis_mmap->rwlock); + } + } +} + +void vis_stop(void) { + if (vis_mmap) { + pthread_rwlock_wrlock(&vis_mmap->rwlock); + vis_mmap->running = false; + pthread_rwlock_unlock(&vis_mmap->rwlock); + } +} + +void output_vis_init(log_level level, u8_t *mac) { + loglevel = level; + + sprintf(vis_shm_path, "/squeezelite-%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); + + mode_t old_mask = umask(000); // allow any user to read our shm when created + + vis_fd = shm_open(vis_shm_path, O_CREAT | O_RDWR, 0666); + if (vis_fd != -1) { + if (ftruncate(vis_fd, sizeof(struct vis_t)) == 0) { + vis_mmap = (struct vis_t *)mmap(NULL, sizeof(struct vis_t), PROT_READ | PROT_WRITE, MAP_SHARED, vis_fd, 0); + } + } + + if (vis_mmap > 0) { + pthread_rwlockattr_t attr; + pthread_rwlockattr_init(&attr); + pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); + pthread_rwlock_init(&vis_mmap->rwlock, &attr); + vis_mmap->buf_size = VIS_BUF_SIZE; + vis_mmap->running = false; + vis_mmap->rate = 44100; + pthread_rwlockattr_destroy(&attr); + LOG_INFO("opened visulizer shared memory as %s", vis_shm_path); + } else { + LOG_WARN("unable to open visualizer shared memory"); + vis_mmap = NULL; + } + + umask(old_mask); +} + +#endif // VISEXPORT diff --git a/pcm.c b/pcm.c new file mode 100644 index 0000000..c867ef5 --- /dev/null +++ b/pcm.c @@ -0,0 +1,386 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#include "squeezelite.h" + +extern log_level loglevel; + +extern struct buffer *streambuf; +extern struct buffer *outputbuf; +extern struct streamstate stream; +extern struct outputstate output; +extern struct decodestate decode; +extern struct processstate process; + +#define LOCK_S mutex_lock(streambuf->mutex) +#define UNLOCK_S mutex_unlock(streambuf->mutex) +#define LOCK_O mutex_lock(outputbuf->mutex) +#define UNLOCK_O mutex_unlock(outputbuf->mutex) +#if PROCESS +#define LOCK_O_direct if (decode.direct) mutex_lock(outputbuf->mutex) +#define UNLOCK_O_direct if (decode.direct) mutex_unlock(outputbuf->mutex) +#define LOCK_O_not_direct if (!decode.direct) mutex_lock(outputbuf->mutex) +#define UNLOCK_O_not_direct if (!decode.direct) mutex_unlock(outputbuf->mutex) +#define IF_DIRECT(x) if (decode.direct) { x } +#define IF_PROCESS(x) if (!decode.direct) { x } +#else +#define LOCK_O_direct mutex_lock(outputbuf->mutex) +#define UNLOCK_O_direct mutex_unlock(outputbuf->mutex) +#define LOCK_O_not_direct +#define UNLOCK_O_not_direct +#define IF_DIRECT(x) { x } +#define IF_PROCESS(x) +#endif + +#define MAX_DECODE_FRAMES 4096 + +static u32_t sample_rates[] = { + 11025, 22050, 32000, 44100, 48000, 8000, 12000, 16000, 24000, 96000, 88200, 176400, 192000, 352800, 384000 +}; + +static u32_t sample_rate; +static u32_t sample_size; +static u32_t channels; +static bool bigendian; +static bool limit; +static u32_t audio_left; +static u32_t bytes_per_frame; + +typedef enum { UNKNOWN = 0, WAVE, AIFF } header_format; + +static void _check_header(void) { + u8_t *ptr = streambuf->readp; + unsigned bytes = min(_buf_used(streambuf), _buf_cont_read(streambuf)); + header_format format = UNKNOWN; + + // simple parsing of wav and aiff headers and get to samples + + if (bytes > 12) { + if (!memcmp(ptr, "RIFF", 4) && !memcmp(ptr+8, "WAVE", 4)) { + LOG_INFO("WAVE"); + format = WAVE; + } else if (!memcmp(ptr, "FORM", 4) && (!memcmp(ptr+8, "AIFF", 4) || !memcmp(ptr+8, "AIFC", 4))) { + LOG_INFO("AIFF"); + format = AIFF; + } + } + + if (format != UNKNOWN) { + ptr += 12; + bytes -= 12; + + while (bytes >= 8) { + char id[5]; + unsigned len; + memcpy(id, ptr, 4); + id[4] = '\0'; + + if (format == WAVE) { + len = *(ptr+4) | *(ptr+5) << 8 | *(ptr+6) << 16| *(ptr+7) << 24; + } else { + len = *(ptr+4) << 24 | *(ptr+5) << 16 | *(ptr+6) << 8 | *(ptr+7); + } + + LOG_INFO("header: %s len: %d", id, len); + + if (format == WAVE && !memcmp(ptr, "data", 4)) { + ptr += 8; + _buf_inc_readp(streambuf, ptr - streambuf->readp); + audio_left = len; + LOG_INFO("audio size: %u", audio_left); + limit = true; + return; + } + + if (format == AIFF && !memcmp(ptr, "SSND", 4) && bytes >= 16) { + unsigned offset = *(ptr+8) << 24 | *(ptr+9) << 16 | *(ptr+10) << 8 | *(ptr+11); + // following 4 bytes is blocksize - ignored + ptr += 8 + 8; + _buf_inc_readp(streambuf, ptr + offset - streambuf->readp); + audio_left = len - 8 - offset; + LOG_INFO("audio size: %u", audio_left); + limit = true; + return; + } + + if (format == WAVE && !memcmp(ptr, "fmt ", 4) && bytes >= 24) { + // override the server parsed values with our own + channels = *(ptr+10) | *(ptr+11) << 8; + sample_rate = *(ptr+12) | *(ptr+13) << 8 | *(ptr+14) << 16 | *(ptr+15) << 24; + sample_size = (*(ptr+22) | *(ptr+23) << 8) / 8; + bigendian = 0; + LOG_INFO("pcm size: %u rate: %u chan: %u bigendian: %u", sample_size, sample_rate, channels, bigendian); + } + + if (format == AIFF && !memcmp(ptr, "COMM", 4) && bytes >= 26) { + int exponent; + // override the server parsed values with our own + channels = *(ptr+8) << 8 | *(ptr+9); + sample_size = (*(ptr+14) << 8 | *(ptr+15)) / 8; + bigendian = 1; + // sample rate is encoded as IEEE 80 bit extended format + // make some assumptions to simplify processing - only use first 32 bits of mantissa + exponent = ((*(ptr+16) & 0x7f) << 8 | *(ptr+17)) - 16383 - 31; + sample_rate = *(ptr+18) << 24 | *(ptr+19) << 16 | *(ptr+20) << 8 | *(ptr+21); + while (exponent < 0) { sample_rate >>= 1; ++exponent; } + while (exponent > 0) { sample_rate <<= 1; --exponent; } + LOG_INFO("pcm size: %u rate: %u chan: %u bigendian: %u", sample_size, sample_rate, channels, bigendian); + } + + if (bytes >= len + 8) { + ptr += len + 8; + bytes -= (len + 8); + } else { + LOG_WARN("run out of data"); + return; + } + } + + } else { + LOG_WARN("unknown format - can't parse header"); + } +} + +static decode_state pcm_decode(void) { + unsigned bytes, in, out; + frames_t frames, count; + u32_t *optr; + u8_t *iptr; + u8_t tmp[16]; + + LOCK_S; + + if (decode.new_stream && stream.state == STREAMING_FILE) { + _check_header(); + } + + LOCK_O_direct; + + bytes = min(_buf_used(streambuf), _buf_cont_read(streambuf)); + + IF_DIRECT( + out = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)) / BYTES_PER_FRAME; + ); + IF_PROCESS( + out = process.max_in_frames; + ); + + if ((stream.state <= DISCONNECT && bytes == 0) || (limit && audio_left == 0)) { + UNLOCK_O_direct; + UNLOCK_S; + return DECODE_COMPLETE; + } + + if (decode.new_stream) { + LOG_INFO("setting track_start"); + LOCK_O_not_direct; + output.next_sample_rate = decode_newstream(sample_rate, output.supported_rates); + output.track_start = outputbuf->writep; + IF_DSD( output.next_dop = false; ) + if (output.fade_mode) _checkfade(true); + decode.new_stream = false; + UNLOCK_O_not_direct; + IF_PROCESS( + out = process.max_in_frames; + ); + bytes_per_frame = channels * sample_size; + } + + IF_DIRECT( + optr = (u32_t *)outputbuf->writep; + ); + IF_PROCESS( + optr = (u32_t *)process.inbuf; + ); + iptr = (u8_t *)streambuf->readp; + + in = bytes / bytes_per_frame; + + // handle frame wrapping round end of streambuf + // - only need if resizing of streambuf does not avoid this, could occur in localfile case + if (in == 0 && bytes > 0 && _buf_used(streambuf) >= bytes_per_frame) { + memcpy(tmp, iptr, bytes); + memcpy(tmp + bytes, streambuf->buf, bytes_per_frame - bytes); + iptr = tmp; + in = 1; + } + + frames = min(in, out); + frames = min(frames, MAX_DECODE_FRAMES); + + if (limit && frames * bytes_per_frame > audio_left) { + LOG_INFO("reached end of audio"); + frames = audio_left / bytes_per_frame; + } + + count = frames * channels; + + if (channels == 2) { + if (sample_size == 1) { + while (count--) { + *optr++ = *iptr++ << 24; + } + } else if (sample_size == 2) { + if (bigendian) { + while (count--) { + *optr++ = *(iptr) << 24 | *(iptr+1) << 16; + iptr += 2; + } + } else { + while (count--) { + *optr++ = *(iptr) << 16 | *(iptr+1) << 24; + iptr += 2; + } + } + } else if (sample_size == 3) { + if (bigendian) { + while (count--) { + *optr++ = *(iptr) << 24 | *(iptr+1) << 16 | *(iptr+2) << 8; + iptr += 3; + } + } else { + while (count--) { + *optr++ = *(iptr) << 8 | *(iptr+1) << 16 | *(iptr+2) << 24; + iptr += 3; + } + } + } else if (sample_size == 4) { + if (bigendian) { + while (count--) { + *optr++ = *(iptr) << 24 | *(iptr+1) << 16 | *(iptr+2) << 8 | *(iptr+3); + iptr += 4; + } + } else { + while (count--) { + *optr++ = *(iptr) | *(iptr+1) << 8 | *(iptr+2) << 16 | *(iptr+3) << 24; + iptr += 4; + } + } + } + } else if (channels == 1) { + if (sample_size == 1) { + while (count--) { + *optr = *iptr++ << 24; + *(optr+1) = *optr; + optr += 2; + } + } else if (sample_size == 2) { + if (bigendian) { + while (count--) { + *optr = *(iptr) << 24 | *(iptr+1) << 16; + *(optr+1) = *optr; + iptr += 2; + optr += 2; + } + } else { + while (count--) { + *optr = *(iptr) << 16 | *(iptr+1) << 24; + *(optr+1) = *optr; + iptr += 2; + optr += 2; + } + } + } else if (sample_size == 3) { + if (bigendian) { + while (count--) { + *optr = *(iptr) << 24 | *(iptr+1) << 16 | *(iptr+2) << 8; + *(optr+1) = *optr; + iptr += 3; + optr += 2; + } + } else { + while (count--) { + *optr = *(iptr) << 8 | *(iptr+1) << 16 | *(iptr+2) << 24; + *(optr+1) = *optr; + iptr += 3; + optr += 2; + } + } + } else if (sample_size == 4) { + if (bigendian) { + while (count--) { + *optr++ = *(iptr) << 24 | *(iptr+1) << 16 | *(iptr+2) << 8 | *(iptr+3); + *(optr+1) = *optr; + iptr += 4; + optr += 2; + } + } else { + while (count--) { + *optr++ = *(iptr) | *(iptr+1) << 8 | *(iptr+2) << 16 | *(iptr+3) << 24; + *(optr+1) = *optr; + iptr += 4; + optr += 2; + } + } + } + } else { + LOG_ERROR("unsupported channels"); + } + + LOG_SDEBUG("decoded %u frames", frames); + + _buf_inc_readp(streambuf, frames * bytes_per_frame); + + if (limit) { + audio_left -= frames * bytes_per_frame; + } + + IF_DIRECT( + _buf_inc_writep(outputbuf, frames * BYTES_PER_FRAME); + ); + IF_PROCESS( + process.in_frames = frames; + ); + + UNLOCK_O_direct; + UNLOCK_S; + + return DECODE_RUNNING; +} + +static void pcm_open(u8_t size, u8_t rate, u8_t chan, u8_t endianness) { + sample_size = size - '0' + 1; + sample_rate = sample_rates[rate - '0']; + channels = chan - '0'; + bigendian = (endianness == '0'); + limit = false; + + LOG_INFO("pcm size: %u rate: %u chan: %u bigendian: %u", sample_size, sample_rate, channels, bigendian); + buf_adjust(streambuf, sample_size * channels); +} + +static void pcm_close(void) { + buf_adjust(streambuf, 1); +} + +struct codec *register_pcm(void) { + static struct codec ret = { + 'p', // id + "aif,pcm", // types + 4096, // min read + 102400, // min space + pcm_open, // open + pcm_close, // close + pcm_decode, // decode + }; + + LOG_INFO("using pcm to decode aif,pcm"); + return &ret; +} diff --git a/process.c b/process.c new file mode 100644 index 0000000..6a107c6 --- /dev/null +++ b/process.c @@ -0,0 +1,193 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// sample processing - only included when building with PROCESS set + +#include "squeezelite.h" + +#if PROCESS + +extern log_level loglevel; + +extern struct buffer *outputbuf; +extern struct decodestate decode; +struct processstate process; +extern struct codec *codec; + +#define LOCK_D mutex_lock(decode.mutex); +#define UNLOCK_D mutex_unlock(decode.mutex); +#define LOCK_O mutex_lock(outputbuf->mutex) +#define UNLOCK_O mutex_unlock(outputbuf->mutex) + +// macros to map to processing functions - currently only resample.c +// this can be made more generic when multiple processing mechanisms get added +#if RESAMPLE +#define SAMPLES_FUNC resample_samples +#define DRAIN_FUNC resample_drain +#define NEWSTREAM_FUNC resample_newstream +#define FLUSH_FUNC resample_flush +#define INIT_FUNC resample_init +#endif + + +// transfer all processed frames to the output buf +static void _write_samples(void) { + size_t frames = process.out_frames; + u32_t *iptr = (u32_t *)process.outbuf; + unsigned cnt = 10; + + LOCK_O; + + while (frames > 0) { + + frames_t f = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)) / BYTES_PER_FRAME; + u32_t *optr = (u32_t *)outputbuf->writep; + + if (f > 0) { + + f = min(f, frames); + + memcpy(optr, iptr, f * BYTES_PER_FRAME); + + frames -= f; + + _buf_inc_writep(outputbuf, f * BYTES_PER_FRAME); + iptr += f * BYTES_PER_FRAME / sizeof(*iptr); + + } else if (cnt--) { + + // there should normally be space in the output buffer, but may need to wait during drain phase + UNLOCK_O; + usleep(10000); + LOCK_O; + + } else { + + // bail out if no space found after 100ms to avoid locking + LOG_ERROR("unable to get space in output buffer"); + UNLOCK_O; + return; + } + } + + UNLOCK_O; +} + +// process samples - called with decode mutex set +void process_samples(void) { + + SAMPLES_FUNC(&process); + + _write_samples(); + + process.in_frames = 0; +} + +// drain at end of track - called with decode mutex set +void process_drain(void) { + bool done; + + do { + + done = DRAIN_FUNC(&process); + + _write_samples(); + + } while (!done); + + LOG_DEBUG("processing track complete - frames in: %lu out: %lu", process.total_in, process.total_out); +} + +// new stream - called with decode mutex set +unsigned process_newstream(bool *direct, unsigned raw_sample_rate, unsigned supported_rates[]) { + + bool active = NEWSTREAM_FUNC(&process, raw_sample_rate, supported_rates); + + LOG_INFO("processing: %s", active ? "active" : "inactive"); + + *direct = !active; + + if (active) { + + unsigned max_in_frames, max_out_frames; + + process.in_frames = process.out_frames = 0; + process.total_in = process.total_out = 0; + + max_in_frames = codec->min_space / BYTES_PER_FRAME ; + + // increase size of output buffer by 10% as output rate is not an exact multiple of input rate + if (process.out_sample_rate % process.in_sample_rate == 0) { + max_out_frames = max_in_frames * (process.out_sample_rate / process.in_sample_rate); + } else { + max_out_frames = (int)(1.1 * (float)max_in_frames * (float)process.out_sample_rate / (float)process.in_sample_rate); + } + + if (process.max_in_frames != max_in_frames) { + LOG_DEBUG("creating process buf in frames: %u", max_in_frames); + if (process.inbuf) free(process.inbuf); + process.inbuf = malloc(max_in_frames * BYTES_PER_FRAME); + process.max_in_frames = max_in_frames; + } + + if (process.max_out_frames != max_out_frames) { + LOG_DEBUG("creating process buf out frames: %u", max_out_frames); + if (process.outbuf) free(process.outbuf); + process.outbuf = malloc(max_out_frames * BYTES_PER_FRAME); + process.max_out_frames = max_out_frames; + } + + if (!process.inbuf || !process.outbuf) { + LOG_ERROR("malloc fail creating process buffers"); + *direct = true; + return raw_sample_rate; + } + + return process.out_sample_rate; + } + + return raw_sample_rate; +} + +// process flush - called with decode mutex set +void process_flush(void) { + + LOG_INFO("process flush"); + + FLUSH_FUNC(); + + process.in_frames = 0; +} + +// init - called with no mutex +void process_init(char *opt) { + + bool enabled = INIT_FUNC(opt); + + memset(&process, 0, sizeof(process)); + + if (enabled) { + LOCK_D; + decode.process = true; + UNLOCK_D; + } +} + +#endif // #if PROCESS diff --git a/resample.c b/resample.c new file mode 100644 index 0000000..6157638 --- /dev/null +++ b/resample.c @@ -0,0 +1,366 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// upsampling using libsoxr - only included if RESAMPLE set + +#include "squeezelite.h" + +#if RESAMPLE + +#include +#include + +extern log_level loglevel; + +struct soxr { + soxr_t resampler; + size_t old_clips; + unsigned long q_recipe; + unsigned long q_flags; + double q_precision; /* Conversion precision (in bits). 20 */ + double q_phase_response; /* 0=minimum, ... 50=linear, ... 100=maximum 50 */ + double q_passband_end; /* 0dB pt. bandwidth to preserve; nyquist=1 0.913 */ + double q_stopband_begin; /* Aliasing/imaging control; > passband_end 1 */ + double scale; + bool max_rate; + bool exception; +#if !LINKALL + // soxr symbols to be dynamically loaded + soxr_io_spec_t (* soxr_io_spec)(soxr_datatype_t itype, soxr_datatype_t otype); + soxr_quality_spec_t (* soxr_quality_spec)(unsigned long recipe, unsigned long flags); + soxr_t (* soxr_create)(double, double, unsigned, soxr_error_t *, + soxr_io_spec_t const *, soxr_quality_spec_t const *, soxr_runtime_spec_t const *); + void (* soxr_delete)(soxr_t); + soxr_error_t (* soxr_process)(soxr_t, soxr_in_t, size_t, size_t *, soxr_out_t, size_t olen, size_t *); + size_t *(* soxr_num_clips)(soxr_t); +#if RESAMPLE_MP + soxr_runtime_spec_t (* soxr_runtime_spec)(unsigned num_threads); +#endif + // soxr_strerror is a macro so not included here +#endif +}; + +static struct soxr *r; + +#if LINKALL +#define SOXR(h, fn, ...) (soxr_ ## fn)(__VA_ARGS__) +#else +#define SOXR(h, fn, ...) (h)->soxr_##fn(__VA_ARGS__) +#endif + + +void resample_samples(struct processstate *process) { + size_t idone, odone; + size_t clip_cnt; + + soxr_error_t error = + SOXR(r, process, r->resampler, process->inbuf, process->in_frames, &idone, process->outbuf, process->max_out_frames, &odone); + if (error) { + LOG_INFO("soxr_process error: %s", soxr_strerror(error)); + return; + } + + if (idone != process->in_frames) { + // should not get here if buffers are big enough... + LOG_ERROR("should not get here - partial sox process: %u of %u processed %u of %u out", + (unsigned)idone, process->in_frames, (unsigned)odone, process->max_out_frames); + } + + process->out_frames = odone; + process->total_in += idone; + process->total_out += odone; + + clip_cnt = *(SOXR(r, num_clips, r->resampler)); + if (clip_cnt - r->old_clips) { + LOG_SDEBUG("resampling clips: %u", (unsigned)(clip_cnt - r->old_clips)); + r->old_clips = clip_cnt; + } +} + +bool resample_drain(struct processstate *process) { + size_t odone; + size_t clip_cnt; + + soxr_error_t error = SOXR(r, process, r->resampler, NULL, 0, NULL, process->outbuf, process->max_out_frames, &odone); + if (error) { + LOG_INFO("soxr_process error: %s", soxr_strerror(error)); + return true; + } + + process->out_frames = odone; + process->total_out += odone; + + clip_cnt = *(SOXR(r, num_clips, r->resampler)); + if (clip_cnt - r->old_clips) { + LOG_DEBUG("resampling clips: %u", (unsigned)(clip_cnt - r->old_clips)); + r->old_clips = clip_cnt; + } + + if (odone == 0) { + + LOG_INFO("resample track complete - total track clips: %u", r->old_clips); + + SOXR(r, delete, r->resampler); + r->resampler = NULL; + + return true; + + } else { + + return false; + } +} + +bool resample_newstream(struct processstate *process, unsigned raw_sample_rate, unsigned supported_rates[]) { + unsigned outrate = 0; + int i; + + if (r->exception) { + // find direct match - avoid resampling + for (i = 0; supported_rates[i]; i++) { + if (raw_sample_rate == supported_rates[i]) { + outrate = raw_sample_rate; + break; + } + } + // else find next highest sync sample rate + while (!outrate && i >= 0) { + if (supported_rates[i] > raw_sample_rate && supported_rates[i] % raw_sample_rate == 0) { + outrate = supported_rates[i]; + break; + } + i--; + } + } + + if (!outrate) { + if (r->max_rate) { + // resample to max rate for device + outrate = supported_rates[0]; + } else { + // resample to max sync sample rate + for (i = 0; supported_rates[i]; i++) { + if (supported_rates[i] % raw_sample_rate == 0 || raw_sample_rate % supported_rates[i] == 0) { + outrate = supported_rates[i]; + break; + } + } + } + if (!outrate) { + outrate = supported_rates[0]; + } + } + + process->in_sample_rate = raw_sample_rate; + process->out_sample_rate = outrate; + + if (r->resampler) { + SOXR(r, delete, r->resampler); + r->resampler = NULL; + } + + if (raw_sample_rate != outrate) { + + soxr_io_spec_t io_spec; + soxr_quality_spec_t q_spec; + soxr_error_t error; +#if RESAMPLE_MP + soxr_runtime_spec_t r_spec; +#endif + + LOG_INFO("resampling from %u -> %u", raw_sample_rate, outrate); + + io_spec = SOXR(r, io_spec, SOXR_INT32_I, SOXR_INT32_I); + io_spec.scale = r->scale; + + q_spec = SOXR(r, quality_spec, r->q_recipe, r->q_flags); + if (r->q_precision > 0) { + q_spec.precision = r->q_precision; + } + if (r->q_passband_end > 0) { + q_spec.passband_end = r->q_passband_end; + } + if (r->q_stopband_begin > 0) { + q_spec.stopband_begin = r->q_stopband_begin; + } + if (r->q_phase_response > -1) { + q_spec.phase_response = r->q_phase_response; + } + +#if RESAMPLE_MP + r_spec = SOXR(r, runtime_spec, 0); // make use of libsoxr OpenMP support allowing parallel execution if multiple cores +#endif + + LOG_DEBUG("resampling with soxr_quality_spec_t[precision: %03.1f, passband_end: %03.6f, stopband_begin: %03.6f, " + "phase_response: %03.1f, flags: 0x%02x], soxr_io_spec_t[scale: %03.2f]", q_spec.precision, + q_spec.passband_end, q_spec.stopband_begin, q_spec.phase_response, q_spec.flags, io_spec.scale); + +#if RESAMPLE_MP + r->resampler = SOXR(r, create, raw_sample_rate, outrate, 2, &error, &io_spec, &q_spec, &r_spec); +#else + r->resampler = SOXR(r, create, raw_sample_rate, outrate, 2, &error, &io_spec, &q_spec, NULL); +#endif + + if (error) { + LOG_INFO("soxr_create error: %s", soxr_strerror(error)); + return false; + } + + r->old_clips = 0; + return true; + + } else { + + LOG_INFO("disable resampling - rates match"); + return false; + } +} + +void resample_flush(void) { + if (r->resampler) { + SOXR(r, delete, r->resampler); + r->resampler = NULL; + } +} + +static bool load_soxr(void) { +#if !LINKALL + void *handle = dlopen(LIBSOXR, RTLD_NOW); + char *err; + + if (!handle) { + LOG_INFO("dlerror: %s", dlerror()); + return false; + } + + r->soxr_io_spec = dlsym(handle, "soxr_io_spec"); + r->soxr_quality_spec = dlsym(handle, "soxr_quality_spec"); + r->soxr_create = dlsym(handle, "soxr_create"); + r->soxr_delete = dlsym(handle, "soxr_delete"); + r->soxr_process = dlsym(handle, "soxr_process"); + r->soxr_num_clips = dlsym(handle, "soxr_num_clips"); +#if RESAMPLE_MP + r->soxr_runtime_spec = dlsym(handle, "soxr_runtime_spec"); +#endif + + if ((err = dlerror()) != NULL) { + LOG_INFO("dlerror: %s", err); + return false; + } + + LOG_INFO("loaded "LIBSOXR); +#endif + + return true; +} + +bool resample_init(char *opt) { + char *recipe = NULL, *flags = NULL; + char *atten = NULL; + char *precision = NULL, *passband_end = NULL, *stopband_begin = NULL, *phase_response = NULL; + + r = malloc(sizeof(struct soxr)); + if (!r) { + LOG_WARN("resampling disabled"); + return false; + } + + r->resampler = NULL; + r->old_clips = 0; + r->max_rate = false; + r->exception = false; + + if (!load_soxr()) { + LOG_WARN("resampling disabled"); + return false; + } + + if (opt) { + recipe = next_param(opt, ':'); + flags = next_param(NULL, ':'); + atten = next_param(NULL, ':'); + precision = next_param(NULL, ':'); + passband_end = next_param(NULL, ':'); + stopband_begin = next_param(NULL, ':'); + phase_response = next_param(NULL, ':'); + } + + // default to HQ (20 bit) if not user specified + r->q_recipe = SOXR_HQ; + r->q_flags = 0; + // default to 1db of attenuation if not user specified + r->scale = pow(10, -1.0 / 20); + // override recipe derived values with user specified values + r->q_precision = 0; + r->q_passband_end = 0; + r->q_stopband_begin = 0; + r->q_phase_response = -1; + + if (recipe && recipe[0] != '\0') { + if (strchr(recipe, 'v')) r->q_recipe = SOXR_VHQ; + if (strchr(recipe, 'h')) r->q_recipe = SOXR_HQ; + if (strchr(recipe, 'm')) r->q_recipe = SOXR_MQ; + if (strchr(recipe, 'l')) r->q_recipe = SOXR_LQ; + if (strchr(recipe, 'q')) r->q_recipe = SOXR_QQ; + if (strchr(recipe, 'L')) r->q_recipe |= SOXR_LINEAR_PHASE; + if (strchr(recipe, 'I')) r->q_recipe |= SOXR_INTERMEDIATE_PHASE; + if (strchr(recipe, 'M')) r->q_recipe |= SOXR_MINIMUM_PHASE; + if (strchr(recipe, 's')) r->q_recipe |= SOXR_STEEP_FILTER; + // X = async resampling to max_rate + if (strchr(recipe, 'X')) r->max_rate = true; + // E = exception, only resample if native rate is not supported + if (strchr(recipe, 'E')) r->exception = true; + } + + if (flags) { + r->q_flags = strtoul(flags, 0, 16); + } + + if (atten) { + double scale = pow(10, -atof(atten) / 20); + if (scale > 0 && scale <= 1.0) { + r->scale = scale; + } + } + + if (precision) { + r->q_precision = atof(precision); + } + + if (passband_end) { + r->q_passband_end = atof(passband_end) / 100; + } + + if (stopband_begin) { + r->q_stopband_begin = atof(stopband_begin) / 100; + } + + if (phase_response) { + r->q_phase_response = atof(phase_response); + } + + LOG_INFO("resampling %s recipe: 0x%02x, flags: 0x%02x, scale: %03.2f, precision: %03.1f, passband_end: %03.5f, stopband_begin: %03.5f, phase_response: %03.1f", + r->max_rate ? "async" : "sync", + r->q_recipe, r->q_flags, r->scale, r->q_precision, r->q_passband_end, r->q_stopband_begin, r->q_phase_response); + + return true; +} + +#endif // #if RESAMPLE diff --git a/slimproto.c b/slimproto.c new file mode 100644 index 0000000..81d2f30 --- /dev/null +++ b/slimproto.c @@ -0,0 +1,921 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#include "squeezelite.h" +#include "slimproto.h" + +static log_level loglevel; + +#define PORT 3483 + +#define MAXBUF 4096 + +#if SL_LITTLE_ENDIAN +#define LOCAL_PLAYER_IP 0x0100007f // 127.0.0.1 +#define LOCAL_PLAYER_PORT 0x9b0d // 3483 +#else +#define LOCAL_PLAYER_IP 0x7f000001 // 127.0.0.1 +#define LOCAL_PLAYER_PORT 0x0d9b // 3483 +#endif + +static sockfd sock = -1; +static in_addr_t slimproto_ip = 0; + +extern struct buffer *streambuf; +extern struct buffer *outputbuf; + +extern struct streamstate stream; +extern struct outputstate output; +extern struct decodestate decode; + +extern struct codec *codecs[]; +#if IR +extern struct irstate ir; +#endif + +event_event wake_e; + +#define LOCK_S mutex_lock(streambuf->mutex) +#define UNLOCK_S mutex_unlock(streambuf->mutex) +#define LOCK_O mutex_lock(outputbuf->mutex) +#define UNLOCK_O mutex_unlock(outputbuf->mutex) +#define LOCK_D mutex_lock(decode.mutex) +#define UNLOCK_D mutex_unlock(decode.mutex) +#if IR +#define LOCK_I mutex_lock(ir.mutex) +#define UNLOCK_I mutex_unlock(ir.mutex) +#endif + +static struct { + u32_t updated; + u32_t stream_start; + u32_t stream_full; + u32_t stream_size; + u64_t stream_bytes; + u32_t output_full; + u32_t output_size; + u32_t frames_played; + u32_t device_frames; + u32_t current_sample_rate; + u32_t last; + stream_state stream_state; +} status; + +int autostart; +bool sentSTMu, sentSTMo, sentSTMl; +u32_t new_server; +char *new_server_cap; +#define PLAYER_NAME_LEN 64 +char player_name[PLAYER_NAME_LEN + 1] = ""; +const char *name_file = NULL; + +void send_packet(u8_t *packet, size_t len) { + u8_t *ptr = packet; + unsigned try = 0; + ssize_t n; + + while (len) { + n = send(sock, ptr, len, MSG_NOSIGNAL); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK && try < 10) { + LOG_DEBUG("retrying (%d) writing to socket", ++try); + usleep(1000); + continue; + } + LOG_INFO("failed writing to socket: %s", strerror(last_error())); + return; + } + ptr += n; + len -= n; + } +} + +static void sendHELO(bool reconnect, const char *fixed_cap, const char *var_cap, u8_t mac[6]) { + const char *base_cap = "Model=squeezelite,AccuratePlayPoints=1,HasDigitalOut=1,HasPolarityInversion=1,Firmware=" VERSION; + struct HELO_packet pkt; + + memset(&pkt, 0, sizeof(pkt)); + memcpy(&pkt.opcode, "HELO", 4); + pkt.length = htonl(sizeof(struct HELO_packet) - 8 + strlen(base_cap) + strlen(fixed_cap) + strlen(var_cap)); + pkt.deviceid = 12; // squeezeplay + pkt.revision = 0; + packn(&pkt.wlan_channellist, reconnect ? 0x4000 : 0x0000); + packN(&pkt.bytes_received_H, (u64_t)status.stream_bytes >> 32); + packN(&pkt.bytes_received_L, (u64_t)status.stream_bytes & 0xffffffff); + memcpy(pkt.mac, mac, 6); + + LOG_INFO("mac: %02x:%02x:%02x:%02x:%02x:%02x", pkt.mac[0], pkt.mac[1], pkt.mac[2], pkt.mac[3], pkt.mac[4], pkt.mac[5]); + + LOG_INFO("cap: %s%s%s", base_cap, fixed_cap, var_cap); + + send_packet((u8_t *)&pkt, sizeof(pkt)); + send_packet((u8_t *)base_cap, strlen(base_cap)); + send_packet((u8_t *)fixed_cap, strlen(fixed_cap)); + send_packet((u8_t *)var_cap, strlen(var_cap)); +} + +static void sendSTAT(const char *event, u32_t server_timestamp) { + struct STAT_packet pkt; + u32_t now = gettime_ms(); + u32_t ms_played; + + if (status.current_sample_rate && status.frames_played && status.frames_played > status.device_frames) { + ms_played = (u32_t)(((u64_t)(status.frames_played - status.device_frames) * (u64_t)1000) / (u64_t)status.current_sample_rate); + if (now > status.updated) ms_played += (now - status.updated); + LOG_SDEBUG("ms_played: %u (frames_played: %u device_frames: %u)", ms_played, status.frames_played, status.device_frames); + } else if (status.frames_played && now > status.stream_start) { + ms_played = now - status.stream_start; + LOG_SDEBUG("ms_played: %u using elapsed time (frames_played: %u device_frames: %u)", ms_played, status.frames_played, status.device_frames); + } else { + LOG_SDEBUG("ms_played: 0"); + ms_played = 0; + } + + memset(&pkt, 0, sizeof(struct STAT_packet)); + memcpy(&pkt.opcode, "STAT", 4); + pkt.length = htonl(sizeof(struct STAT_packet) - 8); + memcpy(&pkt.event, event, 4); + // num_crlf + // mas_initialized; mas_mode; + packN(&pkt.stream_buffer_fullness, status.stream_full); + packN(&pkt.stream_buffer_size, status.stream_size); + packN(&pkt.bytes_received_H, (u64_t)status.stream_bytes >> 32); + packN(&pkt.bytes_received_L, (u64_t)status.stream_bytes & 0xffffffff); + pkt.signal_strength = 0xffff; + packN(&pkt.jiffies, now); + packN(&pkt.output_buffer_size, status.output_size); + packN(&pkt.output_buffer_fullness, status.output_full); + packN(&pkt.elapsed_seconds, ms_played / 1000); + // voltage; + packN(&pkt.elapsed_milliseconds, ms_played); + pkt.server_timestamp = server_timestamp; // keep this is server format - don't unpack/pack + // error_code; + + LOG_DEBUG("STAT: %s", event); + + if (loglevel == lSDEBUG) { + LOG_SDEBUG("received bytesL: %u streambuf: %u outputbuf: %u calc elapsed: %u real elapsed: %u (diff: %d) device: %u delay: %d", + (u32_t)status.stream_bytes, status.stream_full, status.output_full, ms_played, now - status.stream_start, + ms_played - now + status.stream_start, status.device_frames * 1000 / status.current_sample_rate, now - status.updated); + } + + send_packet((u8_t *)&pkt, sizeof(pkt)); +} + +static void sendDSCO(disconnect_code disconnect) { + struct DSCO_packet pkt; + + memset(&pkt, 0, sizeof(pkt)); + memcpy(&pkt.opcode, "DSCO", 4); + pkt.length = htonl(sizeof(pkt) - 8); + pkt.reason = disconnect & 0xFF; + + LOG_DEBUG("DSCO: %d", disconnect); + + send_packet((u8_t *)&pkt, sizeof(pkt)); +} + +static void sendRESP(const char *header, size_t len) { + struct RESP_header pkt_header; + + memset(&pkt_header, 0, sizeof(pkt_header)); + memcpy(&pkt_header.opcode, "RESP", 4); + pkt_header.length = htonl(sizeof(pkt_header) + len - 8); + + LOG_DEBUG("RESP"); + + send_packet((u8_t *)&pkt_header, sizeof(pkt_header)); + send_packet((u8_t *)header, len); +} + +static void sendMETA(const char *meta, size_t len) { + struct META_header pkt_header; + + memset(&pkt_header, 0, sizeof(pkt_header)); + memcpy(&pkt_header.opcode, "META", 4); + pkt_header.length = htonl(sizeof(pkt_header) + len - 8); + + LOG_DEBUG("META"); + + send_packet((u8_t *)&pkt_header, sizeof(pkt_header)); + send_packet((u8_t *)meta, len); +} + +static void sendSETDName(const char *name) { + struct SETD_header pkt_header; + + memset(&pkt_header, 0, sizeof(pkt_header)); + memcpy(&pkt_header.opcode, "SETD", 4); + + pkt_header.id = 0; // id 0 is playername S:P:Squeezebox2 + pkt_header.length = htonl(sizeof(pkt_header) + strlen(name) + 1 - 8); + + LOG_DEBUG("set playername: %s", name); + + send_packet((u8_t *)&pkt_header, sizeof(pkt_header)); + send_packet((u8_t *)name, strlen(name) + 1); +} + +#if IR +void sendIR(u32_t code, u32_t ts) { + struct IR_packet pkt; + + memset(&pkt, 0, sizeof(pkt)); + memcpy(&pkt.opcode, "IR ", 4); + pkt.length = htonl(sizeof(pkt) - 8); + + packN(&pkt.jiffies, ts); + pkt.ir_code = htonl(code); + + LOG_DEBUG("IR: ir code: 0x%x ts: %u", code, ts); + + send_packet((u8_t *)&pkt, sizeof(pkt)); +} +#endif + +static void process_strm(u8_t *pkt, int len) { + struct strm_packet *strm = (struct strm_packet *)pkt; + + LOG_DEBUG("strm command %c", strm->command); + + switch(strm->command) { + case 't': + sendSTAT("STMt", strm->replay_gain); // STMt replay_gain is no longer used to track latency, but support it + break; + case 'q': + decode_flush(); + output_flush(); + status.frames_played = 0; + stream_disconnect(); + sendSTAT("STMf", 0); + buf_flush(streambuf); + break; + case 'f': + decode_flush(); + output_flush(); + status.frames_played = 0; + if (stream_disconnect()) { + sendSTAT("STMf", 0); + } + buf_flush(streambuf); + break; + case 'p': + { + unsigned interval = unpackN(&strm->replay_gain); + LOCK_O; + output.pause_frames = interval * status.current_sample_rate / 1000; + if (interval) { + output.state = OUTPUT_PAUSE_FRAMES; + } else { + output.state = OUTPUT_STOPPED; + output.stop_time = gettime_ms(); + } + UNLOCK_O; + if (!interval) sendSTAT("STMp", 0); + LOG_DEBUG("pause interval: %u", interval); + } + break; + case 'a': + { + unsigned interval = unpackN(&strm->replay_gain); + LOCK_O; + output.skip_frames = interval * status.current_sample_rate / 1000; + output.state = OUTPUT_SKIP_FRAMES; + UNLOCK_O; + LOG_DEBUG("skip ahead interval: %u", interval); + } + break; + case 'u': + { + unsigned jiffies = unpackN(&strm->replay_gain); + LOCK_O; + output.state = jiffies ? OUTPUT_START_AT : OUTPUT_RUNNING; + output.start_at = jiffies; + UNLOCK_O; + LOG_DEBUG("unpause at: %u now: %u", jiffies, gettime_ms()); + sendSTAT("STMr", 0); + } + break; + case 's': + { + unsigned header_len = len - sizeof(struct strm_packet); + char *header = (char *)(pkt + sizeof(struct strm_packet)); + in_addr_t ip = (in_addr_t)strm->server_ip; // keep in network byte order + u16_t port = strm->server_port; // keep in network byte order + if (ip == 0) ip = slimproto_ip; + + LOG_DEBUG("strm s autostart: %c transition period: %u transition type: %u codec: %c", + strm->autostart, strm->transition_period, strm->transition_type - '0', strm->format); + + autostart = strm->autostart - '0'; + sendSTAT("STMf", 0); + if (header_len > MAX_HEADER -1) { + LOG_WARN("header too long: %u", header_len); + break; + } + if (strm->format != '?') { + codec_open(strm->format, strm->pcm_sample_size, strm->pcm_sample_rate, strm->pcm_channels, strm->pcm_endianness); + } else if (autostart >= 2) { + // extension to slimproto to allow server to detect codec from response header and send back in codc message + LOG_DEBUG("streaming unknown codec"); + } else { + LOG_WARN("unknown codec requires autostart >= 2"); + break; + } + if (ip == LOCAL_PLAYER_IP && port == LOCAL_PLAYER_PORT) { + // extension to slimproto for LocalPlayer - header is filename not http header, don't expect cont + stream_file(header, header_len, strm->threshold * 1024); + autostart -= 2; + } else { + stream_sock(ip, port, header, header_len, strm->threshold * 1024, autostart >= 2); + } + sendSTAT("STMc", 0); + sentSTMu = sentSTMo = sentSTMl = false; + LOCK_O; + output.threshold = strm->output_threshold; + output.next_replay_gain = unpackN(&strm->replay_gain); + output.fade_mode = strm->transition_type - '0'; + output.fade_secs = strm->transition_period; + output.invert = (strm->flags & 0x03) == 0x03; + LOG_DEBUG("set fade mode: %u", output.fade_mode); + UNLOCK_O; + } + break; + default: + LOG_WARN("unhandled strm %c", strm->command); + break; + } +} + +static void process_cont(u8_t *pkt, int len) { + struct cont_packet *cont = (struct cont_packet *)pkt; + cont->metaint = unpackN(&cont->metaint); + + LOG_DEBUG("cont metaint: %u loop: %u", cont->metaint, cont->loop); + + if (autostart > 1) { + autostart -= 2; + LOCK_S; + if (stream.state == STREAMING_WAIT) { + stream.state = STREAMING_BUFFERING; + stream.meta_interval = stream.meta_next = cont->metaint; + } + UNLOCK_S; + wake_controller(); + } +} + +static void process_codc(u8_t *pkt, int len) { + struct codc_packet *codc = (struct codc_packet *)pkt; + + LOG_DEBUG("codc: %c", codc->format); + codec_open(codc->format, codc->pcm_sample_size, codc->pcm_sample_rate, codc->pcm_channels, codc->pcm_endianness); +} + +static void process_aude(u8_t *pkt, int len) { + struct aude_packet *aude = (struct aude_packet *)pkt; + + LOG_DEBUG("enable spdif: %d dac: %d", aude->enable_spdif, aude->enable_dac); + + LOCK_O; + if (!aude->enable_spdif && output.state != OUTPUT_OFF) { + output.state = OUTPUT_OFF; + } + if (aude->enable_spdif && output.state == OUTPUT_OFF && !output.idle_to) { + output.state = OUTPUT_STOPPED; + output.stop_time = gettime_ms(); + } + UNLOCK_O; +} + +static void process_audg(u8_t *pkt, int len) { + struct audg_packet *audg = (struct audg_packet *)pkt; + audg->gainL = unpackN(&audg->gainL); + audg->gainR = unpackN(&audg->gainR); + + LOG_DEBUG("audg gainL: %u gainR: %u adjust: %u", audg->gainL, audg->gainR, audg->adjust); + + set_volume(audg->adjust ? audg->gainL : FIXED_ONE, audg->adjust ? audg->gainR : FIXED_ONE); +} + +static void process_setd(u8_t *pkt, int len) { + struct setd_packet *setd = (struct setd_packet *)pkt; + + // handle player name query and change + if (setd->id == 0) { + if (len == 5) { + if (strlen(player_name)) { + sendSETDName(player_name); + } + } else if (len > 5) { + strncpy(player_name, setd->data, PLAYER_NAME_LEN); + player_name[PLAYER_NAME_LEN] = '\0'; + LOG_INFO("set name: %s", setd->data); + // confirm change to server + sendSETDName(setd->data); + // write name to name_file if -N option set + if (name_file) { + FILE *fp = fopen(name_file, "w"); + if (fp) { + LOG_INFO("storing name in %s", name_file); + fputs(player_name, fp); + fclose(fp); + } else { + LOG_WARN("unable to store new name in %s", name_file); + } + } + } + } +} + +#define SYNC_CAP ",SyncgroupID=" +#define SYNC_CAP_LEN 13 + +static void process_serv(u8_t *pkt, int len) { + struct serv_packet *serv = (struct serv_packet *)pkt; + + LOG_INFO("switch server"); + + new_server = serv->server_ip; + + if (len - sizeof(struct serv_packet) == 10) { + if (!new_server_cap) { + new_server_cap = malloc(SYNC_CAP_LEN + 10 + 1); + } + new_server_cap[0] = '\0'; + strcat(new_server_cap, SYNC_CAP); + strncat(new_server_cap, (const char *)(pkt + sizeof(struct serv_packet)), 10); + } else { + if (new_server_cap) { + free(new_server_cap); + new_server_cap = NULL; + } + } +} + +struct handler { + char opcode[5]; + void (*handler)(u8_t *, int); +}; + +static struct handler handlers[] = { + { "strm", process_strm }, + { "cont", process_cont }, + { "codc", process_codc }, + { "aude", process_aude }, + { "audg", process_audg }, + { "setd", process_setd }, + { "serv", process_serv }, + { "", NULL }, +}; + +static void process(u8_t *pack, int len) { + struct handler *h = handlers; + while (h->handler && strncmp((char *)pack, h->opcode, 4)) { h++; } + + if (h->handler) { + LOG_DEBUG("%s", h->opcode); + h->handler(pack, len); + } else { + pack[4] = '\0'; + LOG_WARN("unhandled %s", (char *)pack); + } +} + +static bool running; + +static void slimproto_run() { + static u8_t buffer[MAXBUF]; + int expect = 0; + int got = 0; + u32_t now; + static u32_t last = 0; + event_handle ehandles[2]; + int timeouts = 0; + + set_readwake_handles(ehandles, sock, wake_e); + + while (running && !new_server) { + + bool wake = false; + event_type ev; + + if ((ev = wait_readwake(ehandles, 1000)) != EVENT_TIMEOUT) { + + if (ev == EVENT_READ) { + + if (expect > 0) { + int n = recv(sock, buffer + got, expect, 0); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK) { + continue; + } + LOG_INFO("error reading from socket: %s", n ? strerror(last_error()) : "closed"); + return; + } + expect -= n; + got += n; + if (expect == 0) { + process(buffer, got); + got = 0; + } + } else if (expect == 0) { + int n = recv(sock, buffer + got, 2 - got, 0); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK) { + continue; + } + LOG_INFO("error reading from socket: %s", n ? strerror(last_error()) : "closed"); + return; + } + got += n; + if (got == 2) { + expect = buffer[0] << 8 | buffer[1]; // length pack 'n' + got = 0; + if (expect > MAXBUF) { + LOG_ERROR("FATAL: slimproto packet too big: %d > %d", expect, MAXBUF); + return; + } + } + } else { + LOG_ERROR("FATAL: negative expect"); + return; + } + + } + + if (ev == EVENT_WAKE) { + wake = true; + } + + timeouts = 0; + + } else if (++timeouts > 35) { + + // expect message from server every 5 seconds, but 30 seconds on mysb.com so timeout after 35 seconds + LOG_INFO("No messages from server - connection dead"); + return; + } + + // update playback state when woken or every 100ms + now = gettime_ms(); + + if (wake || now - last > 100 || last > now) { + bool _sendSTMs = false; + bool _sendDSCO = false; + bool _sendRESP = false; + bool _sendMETA = false; + bool _sendSTMd = false; + bool _sendSTMt = false; + bool _sendSTMl = false; + bool _sendSTMu = false; + bool _sendSTMo = false; + bool _sendSTMn = false; + bool _stream_disconnect = false; + bool _start_output = false; + decode_state _decode_state; + disconnect_code disconnect_code; + static char header[MAX_HEADER]; + size_t header_len = 0; +#if IR + bool _sendIR = false; + u32_t ir_code, ir_ts; +#endif + last = now; + + LOCK_S; + status.stream_full = _buf_used(streambuf); + status.stream_size = streambuf->size; + status.stream_bytes = stream.bytes; + status.stream_state = stream.state; + + if (stream.state == DISCONNECT) { + disconnect_code = stream.disconnect; + stream.state = STOPPED; + _sendDSCO = true; + } + if (!stream.sent_headers && + (stream.state == STREAMING_HTTP || stream.state == STREAMING_WAIT || stream.state == STREAMING_BUFFERING)) { + header_len = stream.header_len; + memcpy(header, stream.header, header_len); + _sendRESP = true; + stream.sent_headers = true; + } + if (stream.meta_send) { + header_len = stream.header_len; + memcpy(header, stream.header, header_len); + _sendMETA = true; + stream.meta_send = false; + } + UNLOCK_S; + + LOCK_D; + if ((status.stream_state == STREAMING_HTTP || status.stream_state == STREAMING_FILE) && !sentSTMl + && decode.state == DECODE_READY) { + if (autostart == 0) { + decode.state = DECODE_RUNNING; + _sendSTMl = true; + sentSTMl = true; + } else if (autostart == 1) { + decode.state = DECODE_RUNNING; + _start_output = true; + } + // autostart 2 and 3 require cont to be received first + } + if (decode.state == DECODE_COMPLETE || decode.state == DECODE_ERROR) { + if (decode.state == DECODE_COMPLETE) _sendSTMd = true; + if (decode.state == DECODE_ERROR) _sendSTMn = true; + decode.state = DECODE_STOPPED; + if (status.stream_state == STREAMING_HTTP || status.stream_state == STREAMING_FILE) { + _stream_disconnect = true; + } + } + _decode_state = decode.state; + UNLOCK_D; + + LOCK_O; + status.output_full = _buf_used(outputbuf); + status.output_size = outputbuf->size; + status.frames_played = output.frames_played_dmp; + status.current_sample_rate = output.current_sample_rate; + status.updated = output.updated; + status.device_frames = output.device_frames; + + if (output.track_started) { + _sendSTMs = true; + output.track_started = false; + status.stream_start = output.track_start_time; + } +#if PORTAUDIO + if (output.pa_reopen) { + _pa_open(); + output.pa_reopen = false; + } +#endif + if (_start_output && (output.state == OUTPUT_STOPPED || OUTPUT_OFF)) { + output.state = OUTPUT_BUFFER; + } + if (output.state == OUTPUT_RUNNING && !sentSTMu && status.output_full == 0 && status.stream_state <= DISCONNECT && + _decode_state == DECODE_STOPPED) { + _sendSTMu = true; + sentSTMu = true; + LOG_DEBUG("output underrun"); + output.state = OUTPUT_STOPPED; + output.stop_time = now; + } + if (output.state == OUTPUT_RUNNING && !sentSTMo && status.output_full == 0 && status.stream_state == STREAMING_HTTP) { + _sendSTMo = true; + sentSTMo = true; + } + if (output.state == OUTPUT_STOPPED && output.idle_to && (now - output.stop_time > output.idle_to)) { + output.state = OUTPUT_OFF; + LOG_DEBUG("output timeout"); + } + if (output.state == OUTPUT_RUNNING && now - status.last > 1000) { + _sendSTMt = true; + status.last = now; + } + UNLOCK_O; + +#if IR + LOCK_I; + if (ir.code) { + _sendIR = true; + ir_code = ir.code; + ir_ts = ir.ts; + ir.code = 0; + } + UNLOCK_I; +#endif + + if (_stream_disconnect) stream_disconnect(); + + // send packets once locks released as packet sending can block + if (_sendDSCO) sendDSCO(disconnect_code); + if (_sendSTMs) sendSTAT("STMs", 0); + if (_sendSTMd) sendSTAT("STMd", 0); + if (_sendSTMt) sendSTAT("STMt", 0); + if (_sendSTMl) sendSTAT("STMl", 0); + if (_sendSTMu) sendSTAT("STMu", 0); + if (_sendSTMo) sendSTAT("STMo", 0); + if (_sendSTMn) sendSTAT("STMn", 0); + if (_sendRESP) sendRESP(header, header_len); + if (_sendMETA) sendMETA(header, header_len); +#if IR + if (_sendIR) sendIR(ir_code, ir_ts); +#endif + } + } +} + +// called from other threads to wake state machine above +void wake_controller(void) { + wake_signal(wake_e); +} + +in_addr_t discover_server(void) { + struct sockaddr_in d; + struct sockaddr_in s; + char *buf; + struct pollfd pollinfo; + + int disc_sock = socket(AF_INET, SOCK_DGRAM, 0); + + socklen_t enable = 1; + setsockopt(disc_sock, SOL_SOCKET, SO_BROADCAST, (const void *)&enable, sizeof(enable)); + + buf = "e"; + + memset(&d, 0, sizeof(d)); + d.sin_family = AF_INET; + d.sin_port = htons(PORT); + d.sin_addr.s_addr = htonl(INADDR_BROADCAST); + + pollinfo.fd = disc_sock; + pollinfo.events = POLLIN; + + do { + + LOG_INFO("sending discovery"); + memset(&s, 0, sizeof(s)); + + if (sendto(disc_sock, buf, 1, 0, (struct sockaddr *)&d, sizeof(d)) < 0) { + LOG_INFO("error sending disovery"); + } + + if (poll(&pollinfo, 1, 5000) == 1) { + char readbuf[10]; + socklen_t slen = sizeof(s); + recvfrom(disc_sock, readbuf, 10, 0, (struct sockaddr *)&s, &slen); + LOG_INFO("got response from: %s:%d", inet_ntoa(s.sin_addr), ntohs(s.sin_port)); + } + + } while (s.sin_addr.s_addr == 0 && running); + + closesocket(disc_sock); + + return s.sin_addr.s_addr; +} + +#define FIXED_CAP_LEN 256 +#define VAR_CAP_LEN 128 + +void slimproto(log_level level, char *server, u8_t mac[6], const char *name, const char *namefile, const char *modelname) { + struct sockaddr_in serv_addr; + static char fixed_cap[FIXED_CAP_LEN], var_cap[VAR_CAP_LEN] = ""; + bool reconnect = false; + unsigned failed_connect = 0; + unsigned slimproto_port = 0; + int i; + + wake_create(wake_e); + + loglevel = level; + running = true; + + if (server) { + server_addr(server, &slimproto_ip, &slimproto_port); + } + + if (!slimproto_ip) { + slimproto_ip = discover_server(); + } + + if (!slimproto_port) { + slimproto_port = PORT; + } + + if (name) { + strncpy(player_name, name, PLAYER_NAME_LEN); + player_name[PLAYER_NAME_LEN] = '\0'; + } + + if (namefile) { + FILE *fp; + name_file = namefile; + fp = fopen(namefile, "r"); + if (fp) { + if (!fgets(player_name, PLAYER_NAME_LEN, fp)) { + player_name[PLAYER_NAME_LEN] = '\0'; + } else { + // strip any \n from fgets response + int len = strlen(player_name); + if (len > 0 && player_name[len - 1] == '\n') { + player_name[len - 1] = '\0'; + } + LOG_INFO("retrieved name %s from %s", player_name, name_file); + } + fclose(fp); + } + } + + if (!running) return; + + LOCK_O; + snprintf(fixed_cap, FIXED_CAP_LEN, ",ModelName=%s,MaxSampleRate=%u", modelname ? modelname : MODEL_NAME_STRING, + output.supported_rates[0]); + + for (i = 0; i < MAX_CODECS; i++) { + if (codecs[i] && codecs[i]->id && strlen(fixed_cap) < FIXED_CAP_LEN - 10) { + strcat(fixed_cap, ","); + strcat(fixed_cap, codecs[i]->types); + } + } + UNLOCK_O; + + memset(&serv_addr, 0, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = slimproto_ip; + serv_addr.sin_port = htons(slimproto_port); + + LOG_INFO("connecting to %s:%d", inet_ntoa(serv_addr.sin_addr), ntohs(serv_addr.sin_port)); + + new_server = 0; + + while (running) { + + if (new_server) { + slimproto_ip = serv_addr.sin_addr.s_addr = new_server; + LOG_INFO("switching server to %s:%d", inet_ntoa(serv_addr.sin_addr), ntohs(serv_addr.sin_port)); + new_server = 0; + reconnect = false; + } + + sock = socket(AF_INET, SOCK_STREAM, 0); + + set_nonblock(sock); + set_nosigpipe(sock); + + if (connect_timeout(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr), 5) != 0) { + + LOG_INFO("unable to connect to server %u", failed_connect); + sleep(5); + + // rediscover server if it was not set at startup + if (!server && ++failed_connect > 5) { + slimproto_ip = serv_addr.sin_addr.s_addr = discover_server(); + } + + } else { + + struct sockaddr_in our_addr; + socklen_t len; + + LOG_INFO("connected"); + + var_cap[0] = '\0'; + failed_connect = 0; + + // check if this is a local player now we are connected & signal to server via 'loc' format + // this requires LocalPlayer server plugin to enable direct file access + len = sizeof(our_addr); + getsockname(sock, (struct sockaddr *) &our_addr, &len); + + if (our_addr.sin_addr.s_addr == serv_addr.sin_addr.s_addr) { + LOG_INFO("local player"); + strcat(var_cap, ",loc"); + } + + // add on any capablity to be sent to the new server + if (new_server_cap) { + strcat(var_cap, new_server_cap); + free(new_server_cap); + new_server_cap = NULL; + } + + sendHELO(reconnect, fixed_cap, var_cap, mac); + + slimproto_run(); + + if (!reconnect) { + reconnect = true; + } + + usleep(100000); + } + + closesocket(sock); + } +} + +void slimproto_stop(void) { + LOG_INFO("slimproto stop"); + running = false; +} diff --git a/slimproto.h b/slimproto.h new file mode 100644 index 0000000..319ee8d --- /dev/null +++ b/slimproto.h @@ -0,0 +1,176 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// packet formats for slimproto + +#pragma pack(push, 1) + +// from S:N:Slimproto _hello_handler +struct HELO_packet { + char opcode[4]; + u32_t length; + u8_t deviceid; + u8_t revision; + u8_t mac[6]; + u8_t uuid[16]; + u16_t wlan_channellist; + u32_t bytes_received_H, bytes_received_L; + char lang[2]; + // u8_t capabilities[]; +}; + +// S:N:Slimproto _stat_handler +struct STAT_packet { + char opcode[4]; + u32_t length; + u32_t event; + u8_t num_crlf; + u8_t mas_initialized; + u8_t mas_mode; + u32_t stream_buffer_size; + u32_t stream_buffer_fullness; + u32_t bytes_received_H; + u32_t bytes_received_L; + u16_t signal_strength; + u32_t jiffies; + u32_t output_buffer_size; + u32_t output_buffer_fullness; + u32_t elapsed_seconds; + u16_t voltage; + u32_t elapsed_milliseconds; + u32_t server_timestamp; + u16_t error_code; +}; + +// S:N:Slimproto _disco_handler +struct DSCO_packet { + char opcode[4]; + u32_t length; + u8_t reason; +}; + +// S:N:Slimproto _http_response_handler +struct RESP_header { + char opcode[4]; + u32_t length; + // char header[] - added in sendRESP +}; + +// S:N:Slimproto _http_metadata_handler +struct META_header { + char opcode[4]; + u32_t length; + // char metadata[] +}; + +// S:N:Slimproto _http_setting_handler +struct SETD_header { + char opcode[4]; + u32_t length; + u8_t id; + // data +}; + +#if IR +struct IR_packet { + char opcode[4]; + u32_t length; + u32_t jiffies; + u8_t format; // ignored by server + u8_t bits; // ignored by server + u32_t ir_code; +}; +#endif + +// from S:P:Squeezebox stream_s +struct strm_packet { + char opcode[4]; + char command; + u8_t autostart; + u8_t format; + u8_t pcm_sample_size; + u8_t pcm_sample_rate; + u8_t pcm_channels; + u8_t pcm_endianness; + u8_t threshold; + u8_t spdif_enable; + u8_t transition_period; + u8_t transition_type; + u8_t flags; + u8_t output_threshold; + u8_t slaves; + u32_t replay_gain; + u16_t server_port; + u32_t server_ip; + //char request_string[]; +}; + +// S:P:Squeezebox2 +struct aude_packet { + char opcode[4]; + u8_t enable_spdif; + u8_t enable_dac; +}; + +// S:P:Squeezebox2 +struct audg_packet { + char opcode[4]; + u32_t old_gainL; // unused + u32_t old_gainR; // unused + u8_t adjust; + u8_t preamp; // unused + u32_t gainL; + u32_t gainR; + // squence ids - unused +}; + +// S:P:Squeezebox2 +struct cont_packet { + char opcode[4]; + u32_t metaint; + u8_t loop; + // guids we don't use +}; + +// S:C:Commands +struct serv_packet { + char opcode[4]; + u32_t server_ip; + // possible sync group +}; + +// S:P:Squeezebox2 +struct setd_packet { + char opcode[4]; + u8_t id; + char data[]; +}; + +// codec open - this is an extension to slimproto to allow the server to read the header and then return decode params +struct codc_packet { + char opcode[4]; + u8_t format; + u8_t pcm_sample_size; + u8_t pcm_sample_rate; + u8_t pcm_channels; + u8_t pcm_endianness; +}; + +#pragma pack(pop) diff --git a/squeezelite.h b/squeezelite.h new file mode 100644 index 0000000..455fdfd --- /dev/null +++ b/squeezelite.h @@ -0,0 +1,664 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// make may define: PORTAUDIO, SELFPIPE, RESAMPLE, RESAMPLE_MP, VISEXPORT, IR, DSD, LINKALL to influence build + +#define VERSION "v1.8" + +#if !defined(MODEL_NAME) +#define MODEL_NAME SqueezeLite +#endif + +#define QUOTE(name) #name +#define STR(macro) QUOTE(macro) +#define MODEL_NAME_STRING STR(MODEL_NAME) + +// build detection +#if defined(linux) +#define LINUX 1 +#define OSX 0 +#define WIN 0 +#define FREEBSD 0 +#elif defined (__APPLE__) +#define LINUX 0 +#define OSX 1 +#define WIN 0 +#define FREEBSD 0 +#elif defined (_MSC_VER) +#define LINUX 0 +#define OSX 0 +#define WIN 1 +#define FREEBSD 0 +#elif defined(__FreeBSD__) +#define LINUX 0 +#define OSX 0 +#define WIN 0 +#define FREEBSD 1 +#else +#error unknown target +#endif + +#if LINUX && !defined(PORTAUDIO) +#define ALSA 1 +#define PORTAUDIO 0 +#else +#define ALSA 0 +#define PORTAUDIO 1 +#endif + +#if LINUX && !defined(SELFPIPE) +#define EVENTFD 1 +#define SELFPIPE 0 +#define WINEVENT 0 +#endif +#if (LINUX && !EVENTFD) || OSX || FREEBSD +#define EVENTFD 0 +#define SELFPIPE 1 +#define WINEVENT 0 +#endif +#if WIN +#define EVENTFD 0 +#define SELFPIPE 0 +#define WINEVENT 1 +#endif + +#if defined(RESAMPLE) || defined(RESAMPLE_MP) +#undef RESAMPLE +#define RESAMPLE 1 // resampling +#define PROCESS 1 // any sample processing (only resampling at present) +#else +#define RESAMPLE 0 +#define PROCESS 0 +#endif +#if defined(RESAMPLE_MP) +#undef RESAMPLE_MP +#define RESAMPLE_MP 1 +#else +#define RESAMPLE_MP 0 +#endif + +#if defined(FFMPEG) +#undef FFMPEG +#define FFMPEG 1 +#else +#define FFMPEG 0 +#endif + +#if LINUX && defined(VISEXPORT) +#undef VISEXPORT +#define VISEXPORT 1 // visulizer export support uses linux shared memory +#else +#define VISEXPORT 0 +#endif + +#if LINUX && defined(IR) +#undef IR +#define IR 1 +#else +#define IR 0 +#endif + +#if defined(DSD) +#undef DSD +#define DSD 1 +#define IF_DSD(x) { x } +#else +#undef DSD +#define DSD 0 +#define IF_DSD(x) +#endif + +#if defined(LINKALL) +#undef LINKALL +#define LINKALL 1 // link all libraries at build time - requires all to be available at run time +#else +#define LINKALL 0 +#endif + + +#if !LINKALL + +// dynamically loaded libraries at run time + +#if LINUX +#define LIBFLAC "libFLAC.so.8" +#define LIBMAD "libmad.so.0" +#define LIBMPG "libmpg123.so.0" +#define LIBVORBIS "libvorbisfile.so.3" +#define LIBTREMOR "libvorbisidec.so.1" +#define LIBFAAD "libfaad.so.2" +#define LIBAVUTIL "libavutil.so.%d" +#define LIBAVCODEC "libavcodec.so.%d" +#define LIBAVFORMAT "libavformat.so.%d" +#define LIBSOXR "libsoxr.so.0" +#define LIBLIRC "liblirc_client.so.0" +#endif + +#if OSX +#define LIBFLAC "libFLAC.8.dylib" +#define LIBMAD "libmad.0.dylib" +#define LIBMPG "libmpg123.0.dylib" +#define LIBVORBIS "libvorbisfile.3.dylib" +#define LIBTREMOR "libvorbisidec.1.dylib" +#define LIBFAAD "libfaad.2.dylib" +#define LIBAVUTIL "libavutil.%d.dylib" +#define LIBAVCODEC "libavcodec.%d.dylib" +#define LIBAVFORMAT "libavformat.%d.dylib" +#define LIBSOXR "libsoxr.0.dylib" +#endif + +#if WIN +#define LIBFLAC "libFLAC.dll" +#define LIBMAD "libmad-0.dll" +#define LIBMPG "libmpg123-0.dll" +#define LIBVORBIS "libvorbisfile.dll" +#define LIBTREMOR "libvorbisidec.dll" +#define LIBFAAD "libfaad2.dll" +#define LIBAVUTIL "avutil-%d.dll" +#define LIBAVCODEC "avcodec-%d.dll" +#define LIBAVFORMAT "avformat-%d.dll" +#define LIBSOXR "libsoxr.dll" +#endif + +#if FREEBSD +#define LIBFLAC "libFLAC.so.11" +#define LIBMAD "libmad.so.2" +#define LIBMPG "libmpg123.so.0" +#define LIBVORBIS "libvorbisfile.so.6" +#define LIBTREMOR "libvorbisidec.so.1" +#define LIBFAAD "libfaad.so.2" +#define LIBAVUTIL "libavutil.so.%d" +#define LIBAVCODEC "libavcodec.so.%d" +#define LIBAVFORMAT "libavformat.so.%d" +#endif + +#endif // !LINKALL + +// config options +#define STREAMBUF_SIZE (2 * 1024 * 1024) +#define OUTPUTBUF_SIZE (44100 * 8 * 10) +#define OUTPUTBUF_SIZE_CROSSFADE (OUTPUTBUF_SIZE * 12 / 10) + +#define MAX_HEADER 4096 // do not reduce as icy-meta max is 4080 + +#if ALSA +#define ALSA_BUFFER_TIME 40 +#define ALSA_PERIOD_COUNT 4 +#define OUTPUT_RT_PRIORITY 45 +#endif + +#define SL_LITTLE_ENDIAN (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) + +#include +#include +#include +#include +#include +#include +#include + +#if LINUX || OSX || FREEBSD +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define STREAM_THREAD_STACK_SIZE 64 * 1024 +#define DECODE_THREAD_STACK_SIZE 128 * 1024 +#define OUTPUT_THREAD_STACK_SIZE 64 * 1024 +#define IR_THREAD_STACK_SIZE 64 * 1024 +#define thread_t pthread_t; +#define closesocket(s) close(s) +#define last_error() errno +#define ERROR_WOULDBLOCK EWOULDBLOCK + +typedef u_int8_t u8_t; +typedef u_int16_t u16_t; +typedef u_int32_t u32_t; +typedef u_int64_t u64_t; +typedef int16_t s16_t; +typedef int32_t s32_t; +typedef int64_t s64_t; + +#define mutex_type pthread_mutex_t +#define mutex_create(m) pthread_mutex_init(&m, NULL) +#define mutex_create_p(m) pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT); pthread_mutex_init(&m, &attr); pthread_mutexattr_destroy(&attr) +#define mutex_lock(m) pthread_mutex_lock(&m) +#define mutex_unlock(m) pthread_mutex_unlock(&m) +#define mutex_destroy(m) pthread_mutex_destroy(&m) +#define thread_type pthread_t + +#endif + +#if WIN + +#include +#include +#include + +#define STREAM_THREAD_STACK_SIZE (1024 * 64) +#define DECODE_THREAD_STACK_SIZE (1024 * 128) +#define OUTPUT_THREAD_STACK_SIZE (1024 * 64) + +typedef unsigned __int8 u8_t; +typedef unsigned __int16 u16_t; +typedef unsigned __int32 u32_t; +typedef unsigned __int64 u64_t; +typedef __int16 s16_t; +typedef __int32 s32_t; +typedef __int64 s64_t; + +typedef BOOL bool; +#define true TRUE +#define false FALSE + +#define inline __inline + +#define mutex_type HANDLE +#define mutex_create(m) m = CreateMutex(NULL, FALSE, NULL) +#define mutex_create_p mutex_create +#define mutex_lock(m) WaitForSingleObject(m, INFINITE) +#define mutex_unlock(m) ReleaseMutex(m) +#define mutex_destroy(m) CloseHandle(m) +#define thread_type HANDLE + +#define usleep(x) Sleep(x/1000) +#define sleep(x) Sleep(x*1000) +#define last_error() WSAGetLastError() +#define ERROR_WOULDBLOCK WSAEWOULDBLOCK +#define open _open +#define read _read +#define snprintf _snprintf + +#define in_addr_t u32_t +#define socklen_t int +#define ssize_t int + +#define RTLD_NOW 0 + +#endif + +#if !defined(MSG_NOSIGNAL) +#define MSG_NOSIGNAL 0 +#endif + +typedef u32_t frames_t; +typedef int sockfd; + +#if EVENTFD +#include +#define event_event int +#define event_handle struct pollfd +#define wake_create(e) e = eventfd(0, 0) +#define wake_signal(e) eventfd_write(e, 1) +#define wake_clear(e) eventfd_t val; eventfd_read(e, &val) +#define wake_close(e) close(e) +#endif + +#if SELFPIPE +#define event_handle struct pollfd +#define event_event struct wake +#define wake_create(e) pipe(e.fds); set_nonblock(e.fds[0]); set_nonblock(e.fds[1]) +#define wake_signal(e) write(e.fds[1], ".", 1) +#define wake_clear(e) char c[10]; read(e, &c, 10) +#define wake_close(e) close(e.fds[0]); close(e.fds[1]) +struct wake { + int fds[2]; +}; +#endif + +#if WINEVENT +#define event_event HANDLE +#define event_handle HANDLE +#define wake_create(e) e = CreateEvent(NULL, FALSE, FALSE, NULL) +#define wake_signal(e) SetEvent(e) +#define wake_close(e) CloseHandle(e) +#endif + +// printf/scanf formats for u64_t +#if (LINUX && __WORDSIZE == 64) || (FREEBSD && __LP64__) +#define FMT_u64 "%lu" +#define FMT_x64 "%lx" +#elif __GLIBC_HAVE_LONG_LONG || defined __GNUC__ || WIN +#define FMT_u64 "%llu" +#define FMT_x64 "%llx" +#else +#error can not support u64_t +#endif + +#define MAX_SILENCE_FRAMES 2048 + +#define FIXED_ONE 0x10000 + +#define BYTES_PER_FRAME 8 + +#define min(a,b) (((a) < (b)) ? (a) : (b)) + +// logging +typedef enum { lERROR = 0, lWARN, lINFO, lDEBUG, lSDEBUG } log_level; + +const char *logtime(void); +void logprint(const char *fmt, ...); + +#define LOG_ERROR(fmt, ...) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOG_WARN(fmt, ...) if (loglevel >= lWARN) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOG_INFO(fmt, ...) if (loglevel >= lINFO) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOG_DEBUG(fmt, ...) if (loglevel >= lDEBUG) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOG_SDEBUG(fmt, ...) if (loglevel >= lSDEBUG) logprint("%s %s:%d " fmt "\n", logtime(), __FUNCTION__, __LINE__, ##__VA_ARGS__) + +// utils.c (non logging) +typedef enum { EVENT_TIMEOUT = 0, EVENT_READ, EVENT_WAKE } event_type; + +char *next_param(char *src, char c); +u32_t gettime_ms(void); +void get_mac(u8_t *mac); +void set_nonblock(sockfd s); +int connect_timeout(sockfd sock, const struct sockaddr *addr, socklen_t addrlen, int timeout); +void server_addr(char *server, in_addr_t *ip_ptr, unsigned *port_ptr); +void set_readwake_handles(event_handle handles[], sockfd s, event_event e); +event_type wait_readwake(event_handle handles[], int timeout); +void packN(u32_t *dest, u32_t val); +void packn(u16_t *dest, u16_t val); +u32_t unpackN(u32_t *src); +u16_t unpackn(u16_t *src); +#if OSX +void set_nosigpipe(sockfd s); +#else +#define set_nosigpipe(s) +#endif +#if WIN +void winsock_init(void); +void winsock_close(void); +void *dlopen(const char *filename, int flag); +void *dlsym(void *handle, const char *symbol); +char *dlerror(void); +int poll(struct pollfd *fds, unsigned long numfds, int timeout); +#endif +#if LINUX || FREEBSD +void touch_memory(u8_t *buf, size_t size); +#endif + +// buffer.c +struct buffer { + u8_t *buf; + u8_t *readp; + u8_t *writep; + u8_t *wrap; + size_t size; + size_t base_size; + mutex_type mutex; +}; + +// _* called with mutex locked +unsigned _buf_used(struct buffer *buf); +unsigned _buf_space(struct buffer *buf); +unsigned _buf_cont_read(struct buffer *buf); +unsigned _buf_cont_write(struct buffer *buf); +void _buf_inc_readp(struct buffer *buf, unsigned by); +void _buf_inc_writep(struct buffer *buf, unsigned by); +void buf_flush(struct buffer *buf); +void buf_adjust(struct buffer *buf, size_t mod); +void _buf_resize(struct buffer *buf, size_t size); +void buf_init(struct buffer *buf, size_t size); +void buf_destroy(struct buffer *buf); + +// slimproto.c +void slimproto(log_level level, char *server, u8_t mac[6], const char *name, const char *namefile, const char *modelname); +void slimproto_stop(void); +void wake_controller(void); + +// stream.c +typedef enum { STOPPED = 0, DISCONNECT, STREAMING_WAIT, + STREAMING_BUFFERING, STREAMING_FILE, STREAMING_HTTP, SEND_HEADERS, RECV_HEADERS } stream_state; +typedef enum { DISCONNECT_OK = 0, LOCAL_DISCONNECT = 1, REMOTE_DISCONNECT = 2, UNREACHABLE = 3, TIMEOUT = 4 } disconnect_code; + +struct streamstate { + stream_state state; + disconnect_code disconnect; + char *header; + size_t header_len; + bool sent_headers; + bool cont_wait; + u64_t bytes; + unsigned threshold; + u32_t meta_interval; + u32_t meta_next; + u32_t meta_left; + bool meta_send; +}; + +void stream_init(log_level level, unsigned stream_buf_size); +void stream_close(void); +void stream_file(const char *header, size_t header_len, unsigned threshold); +void stream_sock(u32_t ip, u16_t port, const char *header, size_t header_len, unsigned threshold, bool cont_wait); +bool stream_disconnect(void); + +// decode.c +typedef enum { DECODE_STOPPED = 0, DECODE_READY, DECODE_RUNNING, DECODE_COMPLETE, DECODE_ERROR } decode_state; + +struct decodestate { + decode_state state; + bool new_stream; + mutex_type mutex; +#if PROCESS + bool direct; + bool process; +#endif +}; + +#if PROCESS +struct processstate { + u8_t *inbuf, *outbuf; + unsigned max_in_frames, max_out_frames; + unsigned in_frames, out_frames; + unsigned in_sample_rate, out_sample_rate; + unsigned long total_in, total_out; +}; +#endif + +struct codec { + char id; + char *types; + unsigned min_read_bytes; + unsigned min_space; + void (*open)(u8_t sample_size, u8_t sample_rate, u8_t channels, u8_t endianness); + void (*close)(void); + decode_state (*decode)(void); +}; + +void decode_init(log_level level, const char *include_codecs, const char *exclude_codecs); +void decode_close(void); +void decode_flush(void); +unsigned decode_newstream(unsigned sample_rate, unsigned supported_rates[]); +void codec_open(u8_t format, u8_t sample_size, u8_t sample_rate, u8_t channels, u8_t endianness); + +#if PROCESS +// process.c +void process_samples(void); +void process_drain(void); +void process_flush(void); +unsigned process_newstream(bool *direct, unsigned raw_sample_rate, unsigned supported_rates[]); +void process_init(char *opt); +#endif + +#if RESAMPLE +// resample.c +void resample_samples(struct processstate *process); +bool resample_drain(struct processstate *process); +bool resample_newstream(struct processstate *process, unsigned raw_sample_rate, unsigned supported_rates[]); +void resample_flush(void); +bool resample_init(char *opt); +#endif + +// output.c output_alsa.c output_pa.c output_pack.c +typedef enum { OUTPUT_OFF = -1, OUTPUT_STOPPED = 0, OUTPUT_BUFFER, OUTPUT_RUNNING, + OUTPUT_PAUSE_FRAMES, OUTPUT_SKIP_FRAMES, OUTPUT_START_AT } output_state; + +typedef enum { S32_LE, S24_LE, S24_3LE, S16_LE } output_format; + +typedef enum { FADE_INACTIVE = 0, FADE_DUE, FADE_ACTIVE } fade_state; +typedef enum { FADE_UP = 1, FADE_DOWN, FADE_CROSS } fade_dir; +typedef enum { FADE_NONE = 0, FADE_CROSSFADE, FADE_IN, FADE_OUT, FADE_INOUT } fade_mode; + +#define MAX_SUPPORTED_SAMPLERATES 16 +#define TEST_RATES = { 384000, 352800, 192000, 176400, 96000, 88200, 48000, 44100, 32000, 24000, 22500, 16000, 12000, 11025, 8000, 0 } + +struct outputstate { + output_state state; + output_format format; + const char *device; +#if ALSA + unsigned buffer; + unsigned period; +#endif + bool track_started; +#if PORTAUDIO + bool pa_reopen; + unsigned latency; + int osx_playnice; +#endif + int (* write_cb)(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR, s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr); + unsigned start_frames; + unsigned frames_played; + unsigned frames_played_dmp;// frames played at the point delay is measured + unsigned current_sample_rate; + unsigned supported_rates[MAX_SUPPORTED_SAMPLERATES]; // ordered largest first so [0] is max_rate + unsigned default_sample_rate; + bool error_opening; + unsigned device_frames; + u32_t updated; + u32_t track_start_time; + u32_t current_replay_gain; + union { + u32_t pause_frames; + u32_t skip_frames; + u32_t start_at; + }; + unsigned next_sample_rate; // set in decode thread + u8_t *track_start; // set in decode thread + u32_t gainL; // set by slimproto + u32_t gainR; // set by slimproto + bool invert; // set by slimproto + u32_t next_replay_gain; // set by slimproto + unsigned threshold; // set by slimproto + fade_state fade; + u8_t *fade_start; + u8_t *fade_end; + fade_dir fade_dir; + fade_mode fade_mode; // set by slimproto + unsigned fade_secs; // set by slimproto + unsigned rate_delay; + bool delay_active; + u32_t stop_time; + u32_t idle_to; +#if DSD + bool next_dop; // set in decode thread + bool dop; + bool has_dop; // set in dop_init - output device supports dop + unsigned dop_delay; // set in dop_init - delay in ms switching to/from dop +#endif +}; + +void output_init_common(log_level level, const char *device, unsigned output_buf_size, unsigned rates[], unsigned idle); +void output_close_common(void); +void output_flush(void); +// _* called with mutex locked +frames_t _output_frames(frames_t avail); +void _checkfade(bool); + +// output_alsa.c +#if ALSA +void list_devices(void); +void list_mixers(const char *output_device); +void set_volume(unsigned left, unsigned right); +bool test_open(const char *device, unsigned rates[]); +void output_init_alsa(log_level level, const char *device, unsigned output_buf_size, char *params, unsigned rates[], + unsigned rate_delay, unsigned rt_priority, unsigned idle, char *volume_mixer, bool mixer_unmute); +void output_close_alsa(void); +#endif + +// output_pa.c +#if PORTAUDIO +void list_devices(void); +void set_volume(unsigned left, unsigned right); +bool test_open(const char *device, unsigned rates[]); +void output_init_pa(log_level level, const char *device, unsigned output_buf_size, char *params, unsigned rates[], unsigned rate_delay, unsigned idle); +void output_close_pa(void); +void _pa_open(void); +#endif + +// output_stdout.c +void output_init_stdout(log_level level, unsigned output_buf_size, char *params, unsigned rates[], unsigned rate_delay); +void output_close_stdout(void); + +// output_pack.c +void _scale_and_pack_frames(void *outputptr, s32_t *inputptr, frames_t cnt, s32_t gainL, s32_t gainR, output_format format); +void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr); +void _apply_gain(struct buffer *outputbuf, frames_t count, s32_t gainL, s32_t gainR); +s32_t gain(s32_t gain, s32_t sample); +s32_t to_gain(float f); + +// output_vis.c +#if VISEXPORT +void _vis_export(struct buffer *outputbuf, struct outputstate *output, frames_t out_frames, bool silence); +void output_vis_init(log_level level, u8_t *mac); +void vis_stop(void); +#else +#define _vis_export(...) +#define vis_stop() +#endif + +// dop.c +#if DSD +bool is_flac_dop(u32_t *lptr, u32_t *rptr, frames_t frames); +void update_dop(u32_t *ptr, frames_t frames, bool invert); +void dop_silence_frames(u32_t *ptr, frames_t frames); +void dop_init(bool enable, unsigned delay); +#endif + +// codecs +#define MAX_CODECS 9 + +struct codec *register_flac(void); +struct codec *register_pcm(void); +struct codec *register_mad(void); +struct codec *register_mpg(void); +struct codec *register_vorbis(void); +struct codec *register_faad(void); +struct codec *register_dsd(void); +struct codec *register_ff(const char *codec); + +// ir.c +#if IR +struct irstate { + mutex_type mutex; + u32_t code; + u32_t ts; +}; + +void ir_init(log_level level, char *lircrc); +void ir_close(void); +#endif diff --git a/stream.c b/stream.c new file mode 100644 index 0000000..3fdb28b --- /dev/null +++ b/stream.c @@ -0,0 +1,433 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +// stream thread + +#include "squeezelite.h" + +#include + +static log_level loglevel; + +static struct buffer buf; +struct buffer *streambuf = &buf; + +#define LOCK mutex_lock(streambuf->mutex) +#define UNLOCK mutex_unlock(streambuf->mutex) + +static sockfd fd; + +struct streamstate stream; + +static void send_header(void) { + char *ptr = stream.header; + int len = stream.header_len; + + unsigned try = 0; + ssize_t n; + + while (len) { + n = send(fd, ptr, len, MSG_NOSIGNAL); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK && try < 10) { + LOG_SDEBUG("retrying (%d) writing to socket", ++try); + usleep(1000); + continue; + } + LOG_INFO("failed writing to socket: %s", strerror(last_error())); + stream.disconnect = LOCAL_DISCONNECT; + stream.state = DISCONNECT; + wake_controller(); + return; + } + LOG_SDEBUG("wrote %d bytes to socket", n); + ptr += n; + len -= n; + } + LOG_SDEBUG("wrote header"); +} + +static bool running = true; + +static void _disconnect(stream_state state, disconnect_code disconnect) { + stream.state = state; + stream.disconnect = disconnect; + closesocket(fd); + fd = -1; + wake_controller(); +} + +static void *stream_thread() { + + while (running) { + + struct pollfd pollinfo; + size_t space; + + LOCK; + + space = min(_buf_space(streambuf), _buf_cont_write(streambuf)); + + if (fd < 0 || !space || stream.state <= STREAMING_WAIT) { + UNLOCK; + usleep(100000); + continue; + } + + if (stream.state == STREAMING_FILE) { + + int n = read(fd, streambuf->writep, space); + if (n == 0) { + LOG_INFO("end of stream"); + _disconnect(DISCONNECT, DISCONNECT_OK); + } + if (n > 0) { + _buf_inc_writep(streambuf, n); + stream.bytes += n; + LOG_SDEBUG("streambuf read %d bytes", n); + } + if (n < 0) { + LOG_WARN("error reading: %s", strerror(last_error())); + _disconnect(DISCONNECT, REMOTE_DISCONNECT); + } + + UNLOCK; + continue; + + } else { + + pollinfo.fd = fd; + pollinfo.events = POLLIN; + if (stream.state == SEND_HEADERS) { + pollinfo.events |= POLLOUT; + } + } + + UNLOCK; + + if (poll(&pollinfo, 1, 100)) { + + LOCK; + + // check socket has not been closed while in poll + if (fd < 0) { + UNLOCK; + continue; + } + + if ((pollinfo.revents & POLLOUT) && stream.state == SEND_HEADERS) { + send_header(); + stream.header_len = 0; + stream.state = RECV_HEADERS; + UNLOCK; + continue; + } + + if (pollinfo.revents & (POLLIN | POLLHUP)) { + + // get response headers + if (stream.state == RECV_HEADERS) { + + // read one byte at a time to catch end of header + char c; + static int endtok; + + int n = recv(fd, &c, 1, 0); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK) { + UNLOCK; + continue; + } + LOG_INFO("error reading headers: %s", n ? strerror(last_error()) : "closed"); + _disconnect(STOPPED, LOCAL_DISCONNECT); + UNLOCK; + continue; + } + + *(stream.header + stream.header_len) = c; + stream.header_len++; + + if (stream.header_len > MAX_HEADER - 1) { + LOG_ERROR("received headers too long: %u", stream.header_len); + _disconnect(DISCONNECT, LOCAL_DISCONNECT); + } + + if (stream.header_len > 1 && (c == '\r' || c == '\n')) { + endtok++; + if (endtok == 4) { + *(stream.header + stream.header_len) = '\0'; + LOG_INFO("headers: len: %d\n%s", stream.header_len, stream.header); + stream.state = stream.cont_wait ? STREAMING_WAIT : STREAMING_BUFFERING; + wake_controller(); + } + } else { + endtok = 0; + } + + UNLOCK; + continue; + } + + // receive icy meta data + if (stream.meta_interval && stream.meta_next == 0) { + + if (stream.meta_left == 0) { + // read meta length + u8_t c; + int n = recv(fd, &c, 1, 0); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK) { + UNLOCK; + continue; + } + LOG_INFO("error reading icy meta: %s", n ? strerror(last_error()) : "closed"); + _disconnect(STOPPED, LOCAL_DISCONNECT); + UNLOCK; + continue; + } + stream.meta_left = 16 * c; + stream.header_len = 0; // amount of received meta data + // MAX_HEADER must be more than meta max of 16 * 255 + } + + if (stream.meta_left) { + int n = recv(fd, stream.header + stream.header_len, stream.meta_left, 0); + if (n <= 0) { + if (n < 0 && last_error() == ERROR_WOULDBLOCK) { + UNLOCK; + continue; + } + LOG_INFO("error reading icy meta: %s", n ? strerror(last_error()) : "closed"); + _disconnect(STOPPED, LOCAL_DISCONNECT); + UNLOCK; + continue; + } + stream.meta_left -= n; + stream.header_len += n; + } + + if (stream.meta_left == 0) { + if (stream.header_len) { + *(stream.header + stream.header_len) = '\0'; + LOG_INFO("icy meta: len: %u\n%s", stream.header_len, stream.header); + stream.meta_send = true; + wake_controller(); + } + stream.meta_next = stream.meta_interval; + UNLOCK; + continue; + } + + // stream body into streambuf + } else { + int n; + + space = min(_buf_space(streambuf), _buf_cont_write(streambuf)); + if (stream.meta_interval) { + space = min(space, stream.meta_next); + } + + n = recv(fd, streambuf->writep, space, 0); + if (n == 0) { + LOG_INFO("end of stream"); + _disconnect(DISCONNECT, DISCONNECT_OK); + } + if (n < 0 && last_error() != ERROR_WOULDBLOCK) { + LOG_INFO("error reading: %s", strerror(last_error())); + _disconnect(DISCONNECT, REMOTE_DISCONNECT); + } + + if (n > 0) { + _buf_inc_writep(streambuf, n); + stream.bytes += n; + if (stream.meta_interval) { + stream.meta_next -= n; + } + } + + if (stream.state == STREAMING_BUFFERING && stream.bytes > stream.threshold) { + stream.state = STREAMING_HTTP; + wake_controller(); + } + + LOG_SDEBUG("streambuf read %d bytes", n); + } + } + + UNLOCK; + + } else { + + LOG_SDEBUG("poll timeout"); + } + } + + return 0; +} + +static thread_type thread; + +void stream_init(log_level level, unsigned stream_buf_size) { + loglevel = level; + + LOG_INFO("init stream"); + LOG_DEBUG("streambuf size: %u", stream_buf_size); + + buf_init(streambuf, stream_buf_size); + if (streambuf->buf == NULL) { + LOG_ERROR("unable to malloc buffer"); + exit(0); + } + + stream.state = STOPPED; + stream.header = malloc(MAX_HEADER); + *stream.header = '\0'; + + fd = -1; + +#if LINUX || FREEBSD + touch_memory(streambuf->buf, streambuf->size); +#endif + +#if LINUX || OSX || FREEBSD + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN + STREAM_THREAD_STACK_SIZE); + pthread_create(&thread, &attr, stream_thread, NULL); + pthread_attr_destroy(&attr); +#endif +#if WIN + thread = CreateThread(NULL, STREAM_THREAD_STACK_SIZE, (LPTHREAD_START_ROUTINE)&stream_thread, NULL, 0, NULL); +#endif +} + +void stream_close(void) { + LOG_INFO("close stream"); + LOCK; + running = false; + UNLOCK; +#if LINUX || OSX || FREEBSD + pthread_join(thread, NULL); +#endif + free(stream.header); + buf_destroy(streambuf); +} + +void stream_file(const char *header, size_t header_len, unsigned threshold) { + buf_flush(streambuf); + + LOCK; + + stream.header_len = header_len; + memcpy(stream.header, header, header_len); + *(stream.header+header_len) = '\0'; + + LOG_INFO("opening local file: %s", stream.header); + +#if WIN + fd = open(stream.header, O_RDONLY | O_BINARY); +#else + fd = open(stream.header, O_RDONLY); +#endif + + stream.state = STREAMING_FILE; + if (fd < 0) { + LOG_INFO("can't open file: %s", stream.header); + stream.state = DISCONNECT; + } + wake_controller(); + + stream.cont_wait = false; + stream.meta_interval = 0; + stream.meta_next = 0; + stream.meta_left = 0; + stream.meta_send = false; + stream.sent_headers = false; + stream.bytes = 0; + stream.threshold = threshold; + + UNLOCK; +} + +void stream_sock(u32_t ip, u16_t port, const char *header, size_t header_len, unsigned threshold, bool cont_wait) { + struct sockaddr_in addr; + + int sock = socket(AF_INET, SOCK_STREAM, 0); + + if (sock < 0) { + LOG_ERROR("failed to create socket"); + return; + } + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = ip; + addr.sin_port = port; + + LOG_INFO("connecting to %s:%d", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port)); + + set_nonblock(sock); + set_nosigpipe(sock); + + if (connect_timeout(sock, (struct sockaddr *) &addr, sizeof(addr), 10) < 0) { + LOG_INFO("unable to connect to server"); + LOCK; + stream.state = DISCONNECT; + stream.disconnect = UNREACHABLE; + UNLOCK; + return; + } + + buf_flush(streambuf); + + LOCK; + + fd = sock; + stream.state = SEND_HEADERS; + stream.cont_wait = cont_wait; + stream.meta_interval = 0; + stream.meta_next = 0; + stream.meta_left = 0; + stream.meta_send = false; + stream.header_len = header_len; + memcpy(stream.header, header, header_len); + *(stream.header+header_len) = '\0'; + + LOG_INFO("header: %s", stream.header); + + stream.sent_headers = false; + stream.bytes = 0; + stream.threshold = threshold; + + UNLOCK; +} + +bool stream_disconnect(void) { + bool disc = false; + LOCK; + if (fd != -1) { + closesocket(fd); + fd = -1; + disc = true; + } + stream.state = STOPPED; + UNLOCK; + return disc; +} diff --git a/utils.c b/utils.c new file mode 100644 index 0000000..ba67d77 --- /dev/null +++ b/utils.c @@ -0,0 +1,388 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#include "squeezelite.h" + +#if LINUX || OSX || FREEBSD +#include +#include +#include +#if FREEBSD +#include +#include +#include +#endif +#endif +#if WIN +#include +#endif +#if OSX +#include +#include +#include +#include +#endif + +#include + +// logging functions +const char *logtime(void) { + static char buf[100]; +#if WIN + SYSTEMTIME lt; + GetLocalTime(<); + sprintf(buf, "[%02d:%02d:%02d.%03d]", lt.wHour, lt.wMinute, lt.wSecond, lt.wMilliseconds); +#else + struct timeval tv; + gettimeofday(&tv, NULL); + strftime(buf, sizeof(buf), "[%T.", localtime(&tv.tv_sec)); + sprintf(buf+strlen(buf), "%06ld]", (long)tv.tv_usec); +#endif + return buf; +} + +void logprint(const char *fmt, ...) { + va_list args; + va_start(args, fmt); + vfprintf(stderr, fmt, args); + fflush(stderr); +} + +// cmdline parsing +char *next_param(char *src, char c) { + static char *str = NULL; + char *ptr, *ret; + if (src) str = src; + if (str && (ptr = strchr(str, c))) { + ret = str; + *ptr = '\0'; + str = ptr + 1; + } else { + ret = str; + str = NULL; + } + + return ret && ret[0] ? ret : NULL; +} + +// clock +u32_t gettime_ms(void) { +#if WIN + return GetTickCount(); +#else +#if LINUX || FREEBSD + struct timespec ts; + if (!clock_gettime(CLOCK_MONOTONIC, &ts)) { + return ts.tv_sec * 1000 + ts.tv_nsec / 1000000; + } +#endif + struct timeval tv; + gettimeofday(&tv, NULL); + return tv.tv_sec * 1000 + tv.tv_usec / 1000; +#endif +} + +// mac address +#if LINUX +// search first 4 interfaces returned by IFCONF +void get_mac(u8_t mac[]) { + struct ifconf ifc; + struct ifreq *ifr, *ifend; + struct ifreq ifreq; + struct ifreq ifs[4]; + + mac[0] = mac[1] = mac[2] = mac[3] = mac[4] = mac[5] = 0; + + int s = socket(AF_INET, SOCK_DGRAM, 0); + + ifc.ifc_len = sizeof(ifs); + ifc.ifc_req = ifs; + + if (ioctl(s, SIOCGIFCONF, &ifc) == 0) { + ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq)); + + for (ifr = ifc.ifc_req; ifr < ifend; ifr++) { + if (ifr->ifr_addr.sa_family == AF_INET) { + + strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name)); + if (ioctl (s, SIOCGIFHWADDR, &ifreq) == 0) { + memcpy(mac, ifreq.ifr_hwaddr.sa_data, 6); + if (mac[0]+mac[1]+mac[2] != 0) { + break; + } + } + } + } + } + + close(s); +} +#endif + +#if OSX || FREEBSD +void get_mac(u8_t mac[]) { + struct ifaddrs *addrs, *ptr; + const struct sockaddr_dl *dlAddr; + const unsigned char *base; + + mac[0] = mac[1] = mac[2] = mac[3] = mac[4] = mac[5] = 0; + + if (getifaddrs(&addrs) == 0) { + ptr = addrs; + while (ptr) { + if (ptr->ifa_addr->sa_family == AF_LINK && ((const struct sockaddr_dl *) ptr->ifa_addr)->sdl_type == IFT_ETHER) { + dlAddr = (const struct sockaddr_dl *)ptr->ifa_addr; + base = (const unsigned char*) &dlAddr->sdl_data[dlAddr->sdl_nlen]; + memcpy(mac, base, min(dlAddr->sdl_alen, 6)); + break; + } + ptr = ptr->ifa_next; + } + freeifaddrs(addrs); + } +} +#endif + +#if WIN +#pragma comment(lib, "IPHLPAPI.lib") +void get_mac(u8_t mac[]) { + IP_ADAPTER_INFO AdapterInfo[16]; + DWORD dwBufLen = sizeof(AdapterInfo); + DWORD dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen); + + mac[0] = mac[1] = mac[2] = mac[3] = mac[4] = mac[5] = 0; + + if (GetAdaptersInfo(AdapterInfo, &dwBufLen) == ERROR_SUCCESS) { + memcpy(mac, AdapterInfo[0].Address, 6); + } +} +#endif + +void set_nonblock(sockfd s) { +#if WIN + u_long iMode = 1; + ioctlsocket(s, FIONBIO, &iMode); +#else + int flags = fcntl(s, F_GETFL,0); + fcntl(s, F_SETFL, flags | O_NONBLOCK); +#endif +} + +// connect for socket already set to non blocking with timeout in seconds +int connect_timeout(sockfd sock, const struct sockaddr *addr, socklen_t addrlen, int timeout) { + fd_set w, e; + struct timeval tval; + + if (connect(sock, addr, addrlen) < 0) { +#if !WIN + if (last_error() != EINPROGRESS) { +#else + if (last_error() != WSAEWOULDBLOCK) { +#endif + return -1; + } + } + + FD_ZERO(&w); + FD_SET(sock, &w); + e = w; + tval.tv_sec = timeout; + tval.tv_usec = 0; + + // only return 0 if w set and sock error is zero, otherwise return error code + if (select(sock + 1, NULL, &w, &e, timeout ? &tval : NULL) == 1 && FD_ISSET(sock, &w)) { + int error = 0; + socklen_t len = sizeof(error); + getsockopt(sock, SOL_SOCKET, SO_ERROR, (void *)&error, &len); + return error; + } + + return -1; +} + +void server_addr(char *server, in_addr_t *ip_ptr, unsigned *port_ptr) { + struct addrinfo *res = NULL; + struct addrinfo hints; + const char *port = NULL; + + if (strtok(server, ":")) { + port = strtok(NULL, ":"); + if (port) { + *port_ptr = atoi(port); + } + } + + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_INET; + + getaddrinfo(server, NULL, &hints, &res); + + if (res && res->ai_addr) { + *ip_ptr = ((struct sockaddr_in*)res->ai_addr)->sin_addr.s_addr; + } + + if (res) { + freeaddrinfo(res); + } +} + +void set_readwake_handles(event_handle handles[], sockfd s, event_event e) { +#if WINEVENT + handles[0] = WSACreateEvent(); + handles[1] = e; + WSAEventSelect(s, handles[0], FD_READ | FD_CLOSE); +#elif SELFPIPE + handles[0].fd = s; + handles[1].fd = e.fds[0]; + handles[0].events = POLLIN; + handles[1].events = POLLIN; +#else + handles[0].fd = s; + handles[1].fd = e; + handles[0].events = POLLIN; + handles[1].events = POLLIN; +#endif +} + +event_type wait_readwake(event_handle handles[], int timeout) { +#if WINEVENT + int wait = WSAWaitForMultipleEvents(2, handles, FALSE, timeout, FALSE); + if (wait == WSA_WAIT_EVENT_0) { + WSAResetEvent(handles[0]); + return EVENT_READ; + } else if (wait == WSA_WAIT_EVENT_0 + 1) { + return EVENT_WAKE; + } else { + return EVENT_TIMEOUT; + } +#else + if (poll(handles, 2, timeout) > 0) { + if (handles[0].revents) { + return EVENT_READ; + } + if (handles[1].revents) { + wake_clear(handles[1].fd); + return EVENT_WAKE; + } + } + return EVENT_TIMEOUT; +#endif +} + +// pack/unpack to network byte order +void packN(u32_t *dest, u32_t val) { + u8_t *ptr = (u8_t *)dest; + *(ptr) = (val >> 24) & 0xFF; *(ptr+1) = (val >> 16) & 0xFF; *(ptr+2) = (val >> 8) & 0xFF; *(ptr+3) = val & 0xFF; +} + +void packn(u16_t *dest, u16_t val) { + u8_t *ptr = (u8_t *)dest; + *(ptr) = (val >> 8) & 0xFF; *(ptr+1) = val & 0xFF; +} + +u32_t unpackN(u32_t *src) { + u8_t *ptr = (u8_t *)src; + return *(ptr) << 24 | *(ptr+1) << 16 | *(ptr+2) << 8 | *(ptr+3); +} + +u16_t unpackn(u16_t *src) { + u8_t *ptr = (u8_t *)src; + return *(ptr) << 8 | *(ptr+1); +} + +#if OSX +void set_nosigpipe(sockfd s) { + int set = 1; + setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int)); +} +#endif + +#if WIN +void winsock_init(void) { + WSADATA wsaData; + WORD wVersionRequested = MAKEWORD(2, 2); + int WSerr = WSAStartup(wVersionRequested, &wsaData); + if (WSerr != 0) { + LOG_ERROR("Bad winsock version"); + exit(1); + } +} + +void winsock_close(void) { + WSACleanup(); +} + +void *dlopen(const char *filename, int flag) { + SetLastError(0); + return LoadLibrary((LPCTSTR)filename); +} + +void *dlsym(void *handle, const char *symbol) { + SetLastError(0); + return (void *)GetProcAddress(handle, symbol); +} + +char *dlerror(void) { + static char ret[32]; + int last = GetLastError(); + if (last) { + sprintf(ret, "code: %i", last); + SetLastError(0); + return ret; + } + return NULL; +} + +// this only implements numfds == 1 +int poll(struct pollfd *fds, unsigned long numfds, int timeout) { + fd_set r, w; + struct timeval tv; + int ret; + + FD_ZERO(&r); + FD_ZERO(&w); + + if (fds[0].events & POLLIN) FD_SET(fds[0].fd, &r); + if (fds[0].events & POLLOUT) FD_SET(fds[0].fd, &w); + + tv.tv_sec = timeout / 1000; + tv.tv_usec = 1000 * (timeout % 1000); + + ret = select(fds[0].fd + 1, &r, &w, NULL, &tv); + + if (ret < 0) return ret; + + fds[0].revents = 0; + if (FD_ISSET(fds[0].fd, &r)) fds[0].revents |= POLLIN; + if (FD_ISSET(fds[0].fd, &w)) fds[0].revents |= POLLOUT; + + return ret; +} + +#endif + +#if LINUX || FREEBSD +void touch_memory(u8_t *buf, size_t size) { + u8_t *ptr; + for (ptr = buf; ptr < buf + size; ptr += sysconf(_SC_PAGESIZE)) { + *ptr = 0; + } +} +#endif diff --git a/vorbis.c b/vorbis.c new file mode 100644 index 0000000..0809bee --- /dev/null +++ b/vorbis.c @@ -0,0 +1,331 @@ +/* + * Squeezelite - lightweight headless squeezebox emulator + * + * (c) Adrian Smith 2012-2015, triode1@btinternet.com + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +#include "squeezelite.h" + +// automatically select between floating point (preferred) and fixed point libraries: +// NOTE: works with Tremor version here: http://svn.xiph.org/trunk/Tremor, not vorbisidec.1.0.2 currently in ubuntu + +// we take common definations from even though we can use tremor at run time +// tremor's OggVorbis_File struct is normally smaller so this is ok, but padding added to malloc in case it is bigger +#define OV_EXCLUDE_STATIC_CALLBACKS + +#include + +struct vorbis { + OggVorbis_File *vf; + bool opened; +#if !LINKALL + // vorbis symbols to be dynamically loaded - from either vorbisfile or vorbisidec (tremor) version of library + vorbis_info *(* ov_info)(OggVorbis_File *vf, int link); + int (* ov_clear)(OggVorbis_File *vf); + long (* ov_read)(OggVorbis_File *vf, char *buffer, int length, int bigendianp, int word, int sgned, int *bitstream); + long (* ov_read_tremor)(OggVorbis_File *vf, char *buffer, int length, int *bitstream); + int (* ov_open_callbacks)(void *datasource, OggVorbis_File *vf, const char *initial, long ibytes, ov_callbacks callbacks); +#endif +}; + +static struct vorbis *v; + +extern log_level loglevel; + +extern struct buffer *streambuf; +extern struct buffer *outputbuf; +extern struct streamstate stream; +extern struct outputstate output; +extern struct decodestate decode; +extern struct processstate process; + +#define LOCK_S mutex_lock(streambuf->mutex) +#define UNLOCK_S mutex_unlock(streambuf->mutex) +#define LOCK_O mutex_lock(outputbuf->mutex) +#define UNLOCK_O mutex_unlock(outputbuf->mutex) +#if PROCESS +#define LOCK_O_direct if (decode.direct) mutex_lock(outputbuf->mutex) +#define UNLOCK_O_direct if (decode.direct) mutex_unlock(outputbuf->mutex) +#define LOCK_O_not_direct if (!decode.direct) mutex_lock(outputbuf->mutex) +#define UNLOCK_O_not_direct if (!decode.direct) mutex_unlock(outputbuf->mutex) +#define IF_DIRECT(x) if (decode.direct) { x } +#define IF_PROCESS(x) if (!decode.direct) { x } +#else +#define LOCK_O_direct mutex_lock(outputbuf->mutex) +#define UNLOCK_O_direct mutex_unlock(outputbuf->mutex) +#define LOCK_O_not_direct +#define UNLOCK_O_not_direct +#define IF_DIRECT(x) { x } +#define IF_PROCESS(x) +#endif + +#if LINKALL +#define OV(h, fn, ...) (ov_ ## fn)(__VA_ARGS__) +#define TREMOR(h) 0 +extern int ov_read_tremor(); // needed to enable compilation, not linked +#else +#define OV(h, fn, ...) (h)->ov_##fn(__VA_ARGS__) +#define TREMOR(h) (h)->ov_read_tremor +#endif + +// called with mutex locked within vorbis_decode to avoid locking O before S +static size_t _read_cb(void *ptr, size_t size, size_t nmemb, void *datasource) { + size_t bytes; + + bytes = min(_buf_used(streambuf), _buf_cont_read(streambuf)); + bytes = min(bytes, size * nmemb); + + memcpy(ptr, streambuf->readp, bytes); + _buf_inc_readp(streambuf, bytes); + + return bytes / size; +} + +// these are needed for older versions of tremor, later versions and libvorbis allow NULL to be used +static int _seek_cb(void *datasource, ogg_int64_t offset, int whence) { return -1; } +static int _close_cb(void *datasource) { return 0; } +static long _tell_cb(void *datasource) { return 0; } + +static decode_state vorbis_decode(void) { + static int channels; + bool end; + frames_t frames; + int bytes, s, n; + u8_t *write_buf; + + LOCK_S; + LOCK_O_direct; + end = (stream.state <= DISCONNECT); + + IF_DIRECT( + frames = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)) / BYTES_PER_FRAME; + ); + IF_PROCESS( + frames = process.max_in_frames; + ); + + if (!frames && end) { + UNLOCK_O_direct; + UNLOCK_S; + return DECODE_COMPLETE; + } + + if (decode.new_stream) { + ov_callbacks cbs; + int err; + struct vorbis_info *info; + + cbs.read_func = _read_cb; + + if (TREMOR(v)) { + cbs.seek_func = _seek_cb; cbs.close_func = _close_cb; cbs.tell_func = _tell_cb; + } else { + cbs.seek_func = NULL; cbs.close_func = NULL; cbs.tell_func = NULL; + } + + if ((err = OV(v, open_callbacks, streambuf, v->vf, NULL, 0, cbs)) < 0) { + LOG_WARN("open_callbacks error: %d", err); + UNLOCK_O_direct; + UNLOCK_S; + return DECODE_COMPLETE; + } + v->opened = true; + + info = OV(v, info, v->vf, -1); + + LOG_INFO("setting track_start"); + LOCK_O_not_direct; + output.next_sample_rate = decode_newstream(info->rate, output.supported_rates); + IF_DSD( output.next_dop = false; ) + output.track_start = outputbuf->writep; + if (output.fade_mode) _checkfade(true); + decode.new_stream = false; + UNLOCK_O_not_direct; + + IF_PROCESS( + frames = process.max_in_frames; + ); + + channels = info->channels; + + if (channels > 2) { + LOG_WARN("too many channels: %d", channels); + UNLOCK_O_direct; + UNLOCK_S; + return DECODE_ERROR; + } + } + + bytes = frames * 2 * channels; // samples returned are 16 bits + + IF_DIRECT( + write_buf = outputbuf->writep; + ); + IF_PROCESS( + write_buf = process.inbuf; + ); + + // write the decoded frames into outputbuf even though they are 16 bits per sample, then unpack them + if (!TREMOR(v)) { +#if SL_LITTLE_ENDIAN + n = OV(v, read, v->vf, (char *)write_buf, bytes, 0, 2, 1, &s); +#else + n = OV(v, read, v->vf, (char *)write_buf, bytes, 1, 2, 1, &s); +#endif + } else { + n = OV(v, read_tremor, v->vf, (char *)write_buf, bytes, &s); + } + + if (n > 0) { + + frames_t count; + s16_t *iptr; + s32_t *optr; + + frames = n / 2 / channels; + count = frames * channels; + + // work backward to unpack samples to 4 bytes per sample + iptr = (s16_t *)write_buf + count; + optr = (s32_t *)write_buf + frames * 2; + + if (channels == 2) { + while (count--) { + *--optr = *--iptr << 16; + } + } else if (channels == 1) { + while (count--) { + *--optr = *--iptr << 16; + *--optr = *iptr << 16; + } + } + + IF_DIRECT( + _buf_inc_writep(outputbuf, frames * BYTES_PER_FRAME); + ); + IF_PROCESS( + process.in_frames = frames; + ); + + LOG_SDEBUG("wrote %u frames", frames); + + } else if (n == 0) { + + LOG_INFO("end of stream"); + UNLOCK_O_direct; + UNLOCK_S; + return DECODE_COMPLETE; + + } else if (n == OV_HOLE) { + + // recoverable hole in stream, seen when skipping + LOG_DEBUG("hole in stream"); + + } else { + + LOG_INFO("ov_read error: %d", n); + UNLOCK_O_direct; + UNLOCK_S; + return DECODE_COMPLETE; + } + + UNLOCK_O_direct; + UNLOCK_S; + + return DECODE_RUNNING; +} + +static void vorbis_open(u8_t size, u8_t rate, u8_t chan, u8_t endianness) { + if (!v->vf) { + v->vf = malloc(sizeof(OggVorbis_File) + 128); // add some padding as struct size may be larger + memset(v->vf, 0, sizeof(OggVorbis_File) + 128); + } else { + if (v->opened) { + OV(v, clear, v->vf); + v->opened = false; + } + } +} + +static void vorbis_close(void) { + if (v->opened) { + OV(v, clear, v->vf); + v->opened = false; + } + free(v->vf); + v->vf = NULL; +} + +static bool load_vorbis() { +#if !LINKALL + void *handle = dlopen(LIBVORBIS, RTLD_NOW); + char *err; + bool tremor = false; + + if (!handle) { + handle = dlopen(LIBTREMOR, RTLD_NOW); + if (handle) { + tremor = true; + } else { + LOG_INFO("dlerror: %s", dlerror()); + return false; + } + } + + v->ov_read = tremor ? NULL : dlsym(handle, "ov_read"); + v->ov_read_tremor = tremor ? dlsym(handle, "ov_read") : NULL; + v->ov_info = dlsym(handle, "ov_info"); + v->ov_clear = dlsym(handle, "ov_clear"); + v->ov_open_callbacks = dlsym(handle, "ov_open_callbacks"); + + if ((err = dlerror()) != NULL) { + LOG_INFO("dlerror: %s", err); + return false; + } + + LOG_INFO("loaded %s", tremor ? LIBTREMOR : LIBVORBIS); +#endif + + return true; +} + +struct codec *register_vorbis(void) { + static struct codec ret = { + 'o', // id + "ogg", // types + 2048, // min read + 20480, // min space + vorbis_open, // open + vorbis_close, // close + vorbis_decode,// decode + }; + + v = malloc(sizeof(struct vorbis)); + if (!v) { + return NULL; + } + + v->vf = NULL; + v->opened = false; + + if (!load_vorbis()) { + return NULL; + } + + LOG_INFO("using vorbis to decode ogg"); + return &ret; +}