httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
/*
|
2013-01-15 18:22:17 +01:00
|
|
|
* Copyright (C) 2003-2013 The Music Player Daemon Project
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
* http://www.musicpd.org
|
|
|
|
*
|
|
|
|
* 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 2 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, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2009-11-12 09:12:38 +01:00
|
|
|
#include "config.h"
|
2013-01-15 18:22:17 +01:00
|
|
|
#include "HttpdOutputPlugin.hxx"
|
|
|
|
#include "HttpdInternal.hxx"
|
|
|
|
#include "HttpdClient.hxx"
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
#include "output_api.h"
|
|
|
|
#include "encoder_plugin.h"
|
|
|
|
#include "encoder_list.h"
|
2011-09-20 07:56:59 +02:00
|
|
|
#include "resolver.h"
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
#include "page.h"
|
2009-04-13 19:35:02 +02:00
|
|
|
#include "icy_server.h"
|
2009-11-07 18:55:16 +01:00
|
|
|
#include "fd_util.h"
|
2013-01-15 21:42:55 +01:00
|
|
|
#include "ServerSocket.hxx"
|
2013-01-15 22:50:49 +01:00
|
|
|
#include "Main.hxx"
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
2009-07-06 14:40:06 +02:00
|
|
|
#include <sys/types.h>
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
2010-06-06 21:53:24 +02:00
|
|
|
#ifdef HAVE_LIBWRAP
|
2011-03-18 19:44:12 +01:00
|
|
|
#include <sys/socket.h> /* needed for AF_UNIX */
|
2010-06-06 21:53:24 +02:00
|
|
|
#include <tcpd.h>
|
|
|
|
#endif
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
#undef G_LOG_DOMAIN
|
|
|
|
#define G_LOG_DOMAIN "httpd_output"
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The quark used for GError.domain.
|
|
|
|
*/
|
|
|
|
static inline GQuark
|
|
|
|
httpd_output_quark(void)
|
|
|
|
{
|
|
|
|
return g_quark_from_static_string("httpd_output");
|
|
|
|
}
|
|
|
|
|
2012-08-14 20:22:32 +02:00
|
|
|
/**
|
|
|
|
* Check whether there is at least one client.
|
|
|
|
*
|
|
|
|
* Caller must lock the mutex.
|
|
|
|
*/
|
|
|
|
G_GNUC_PURE
|
|
|
|
static bool
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_has_clients(const httpd_output *httpd)
|
2012-08-14 20:22:32 +02:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
return !httpd->clients.empty();
|
2012-08-14 20:22:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check whether there is at least one client.
|
|
|
|
*/
|
|
|
|
G_GNUC_PURE
|
|
|
|
static bool
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_lock_has_clients(const httpd_output *httpd)
|
2012-08-14 20:22:32 +02:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
|
|
|
return httpd_output_has_clients(httpd);
|
2012-08-14 20:22:32 +02:00
|
|
|
}
|
|
|
|
|
2010-10-05 20:37:18 +02:00
|
|
|
static void
|
|
|
|
httpd_listen_in_event(int fd, const struct sockaddr *address,
|
|
|
|
size_t address_length, int uid, void *ctx);
|
2009-11-07 16:52:44 +01:00
|
|
|
|
|
|
|
static bool
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_bind(httpd_output *httpd, GError **error_r)
|
2009-11-07 16:52:44 +01:00
|
|
|
{
|
|
|
|
httpd->open = false;
|
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
|
|
|
return server_socket_open(httpd->server_socket, error_r);
|
2009-11-07 16:52:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_unbind(httpd_output *httpd)
|
2009-11-07 16:52:44 +01:00
|
|
|
{
|
|
|
|
assert(!httpd->open);
|
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
2010-10-05 20:37:18 +02:00
|
|
|
server_socket_close(httpd->server_socket);
|
2009-11-07 16:52:44 +01:00
|
|
|
}
|
|
|
|
|
2011-09-16 23:31:48 +02:00
|
|
|
static struct audio_output *
|
|
|
|
httpd_output_init(const struct config_param *param,
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
GError **error)
|
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = new httpd_output();
|
2011-09-16 23:31:48 +02:00
|
|
|
if (!ao_base_init(&httpd->base, &httpd_output_plugin, param, error)) {
|
|
|
|
g_free(httpd);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
/* read configuration */
|
2010-04-05 13:11:10 +02:00
|
|
|
httpd->name =
|
|
|
|
config_get_block_string(param, "name", "Set name in config");
|
|
|
|
httpd->genre =
|
|
|
|
config_get_block_string(param, "genre", "Set genre in config");
|
|
|
|
httpd->website =
|
|
|
|
config_get_block_string(param, "website", "Set website in config");
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2012-10-01 23:52:40 +02:00
|
|
|
guint port = config_get_block_unsigned(param, "port", 8000);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2012-10-01 23:52:40 +02:00
|
|
|
const char *encoder_name =
|
|
|
|
config_get_block_string(param, "encoder", "vorbis");
|
|
|
|
const struct encoder_plugin *encoder_plugin =
|
|
|
|
encoder_plugin_get(encoder_name);
|
2009-03-17 06:52:23 +01:00
|
|
|
if (encoder_plugin == NULL) {
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
g_set_error(error, httpd_output_quark(), 0,
|
|
|
|
"No such encoder: %s", encoder_name);
|
2011-09-16 23:31:48 +02:00
|
|
|
ao_base_finish(&httpd->base);
|
2011-07-18 14:35:04 +02:00
|
|
|
g_free(httpd);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-10-29 22:38:18 +01:00
|
|
|
httpd->clients_max = config_get_block_unsigned(param,"max_clients", 0);
|
|
|
|
|
2010-09-25 15:00:43 +02:00
|
|
|
/* set up bind_to_address */
|
2010-10-05 20:37:18 +02:00
|
|
|
|
2013-01-15 22:50:49 +01:00
|
|
|
httpd->server_socket = server_socket_new(*main_loop,
|
|
|
|
httpd_listen_in_event, httpd);
|
2010-10-05 20:37:18 +02:00
|
|
|
|
2012-10-01 23:52:40 +02:00
|
|
|
const char *bind_to_address =
|
2010-10-05 20:37:18 +02:00
|
|
|
config_get_block_string(param, "bind_to_address", NULL);
|
|
|
|
bool success = bind_to_address != NULL &&
|
|
|
|
strcmp(bind_to_address, "any") != 0
|
|
|
|
? server_socket_add_host(httpd->server_socket, bind_to_address,
|
|
|
|
port, error)
|
|
|
|
: server_socket_add_port(httpd->server_socket, port, error);
|
2011-09-16 23:31:48 +02:00
|
|
|
if (!success) {
|
|
|
|
ao_base_finish(&httpd->base);
|
|
|
|
g_free(httpd);
|
2010-09-25 15:00:43 +02:00
|
|
|
return NULL;
|
2011-09-16 23:31:48 +02:00
|
|
|
}
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2009-04-13 19:35:02 +02:00
|
|
|
/* initialize metadata */
|
|
|
|
httpd->metadata = NULL;
|
2011-02-04 10:22:00 +01:00
|
|
|
httpd->unflushed_input = 0;
|
2009-04-13 19:35:02 +02:00
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
/* initialize encoder */
|
|
|
|
|
|
|
|
httpd->encoder = encoder_init(encoder_plugin, param, error);
|
2011-09-16 23:31:48 +02:00
|
|
|
if (httpd->encoder == NULL) {
|
|
|
|
ao_base_finish(&httpd->base);
|
|
|
|
g_free(httpd);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return NULL;
|
2011-09-16 23:31:48 +02:00
|
|
|
}
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2009-12-03 20:27:08 +01:00
|
|
|
/* determine content type */
|
|
|
|
httpd->content_type = encoder_get_mime_type(httpd->encoder);
|
|
|
|
if (httpd->content_type == NULL) {
|
|
|
|
httpd->content_type = "application/octet-stream";
|
|
|
|
}
|
|
|
|
|
2011-09-16 23:31:48 +02:00
|
|
|
return &httpd->base;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_finish(struct audio_output *ao)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2009-04-13 19:35:02 +02:00
|
|
|
if (httpd->metadata)
|
|
|
|
page_unref(httpd->metadata);
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
encoder_finish(httpd->encoder);
|
2010-10-05 20:37:18 +02:00
|
|
|
server_socket_free(httpd->server_socket);
|
2011-09-16 23:31:48 +02:00
|
|
|
ao_base_finish(&httpd->base);
|
2013-01-15 18:22:17 +01:00
|
|
|
delete httpd;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-15 18:22:17 +01:00
|
|
|
* Creates a new #HttpdClient object and adds it into the
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
* httpd_output.clients linked list.
|
|
|
|
*/
|
|
|
|
static void
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_client_add(httpd_output *httpd, int fd)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd->clients.emplace_front(httpd, fd,
|
|
|
|
httpd->encoder->plugin->tag == NULL);
|
2009-10-29 22:38:18 +01:00
|
|
|
httpd->clients_cnt++;
|
2009-04-13 19:35:02 +02:00
|
|
|
|
|
|
|
/* pass metadata to client */
|
|
|
|
if (httpd->metadata)
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd->clients.front().PushMetaData(httpd->metadata);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
2010-10-05 20:37:18 +02:00
|
|
|
static void
|
|
|
|
httpd_listen_in_event(int fd, const struct sockaddr *address,
|
|
|
|
size_t address_length, G_GNUC_UNUSED int uid, void *ctx)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ctx;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
|
|
|
/* the listener socket has become readable - a client has
|
|
|
|
connected */
|
|
|
|
|
2010-06-06 21:53:24 +02:00
|
|
|
#ifdef HAVE_LIBWRAP
|
2010-10-05 20:37:18 +02:00
|
|
|
if (address->sa_family != AF_UNIX) {
|
|
|
|
char *hostaddr = sockaddr_to_string(address, address_length, NULL);
|
2010-06-06 21:53:24 +02:00
|
|
|
const char *progname = g_get_prgname();
|
|
|
|
|
|
|
|
struct request_info req;
|
|
|
|
request_init(&req, RQ_FILE, fd, RQ_DAEMON, progname, 0);
|
|
|
|
|
|
|
|
fromhost(&req);
|
|
|
|
|
|
|
|
if (!hosts_access(&req)) {
|
|
|
|
/* tcp wrappers says no */
|
|
|
|
g_warning("libwrap refused connection (libwrap=%s) from %s",
|
|
|
|
progname, hostaddr);
|
|
|
|
g_free(hostaddr);
|
2011-09-19 21:04:19 +02:00
|
|
|
close_socket(fd);
|
2010-10-05 20:37:18 +02:00
|
|
|
return;
|
2010-06-06 21:53:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
g_free(hostaddr);
|
|
|
|
}
|
2010-10-05 20:37:18 +02:00
|
|
|
#else
|
|
|
|
(void)address;
|
|
|
|
(void)address_length;
|
2010-06-06 21:53:24 +02:00
|
|
|
#endif /* HAVE_WRAP */
|
2010-10-05 20:37:18 +02:00
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
2010-10-05 20:37:18 +02:00
|
|
|
|
2009-10-29 22:38:18 +01:00
|
|
|
if (fd >= 0) {
|
|
|
|
/* can we allow additional client */
|
2009-11-05 23:47:29 +01:00
|
|
|
if (httpd->open &&
|
|
|
|
(httpd->clients_max == 0 ||
|
|
|
|
httpd->clients_cnt < httpd->clients_max))
|
2009-10-29 22:38:18 +01:00
|
|
|
httpd_client_add(httpd, fd);
|
|
|
|
else
|
2011-09-19 21:04:19 +02:00
|
|
|
close_socket(fd);
|
2009-10-29 22:38:18 +01:00
|
|
|
} else if (fd < 0 && errno != EINTR) {
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
g_warning("accept() failed: %s", g_strerror(errno));
|
2009-10-29 22:38:18 +01:00
|
|
|
}
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads data from the encoder (as much as available) and returns it
|
|
|
|
* as a new #page object.
|
|
|
|
*/
|
|
|
|
static struct page *
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_read_page(httpd_output *httpd)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2010-08-06 22:18:01 +02:00
|
|
|
if (httpd->unflushed_input >= 65536) {
|
|
|
|
/* we have fed a lot of input into the encoder, but it
|
|
|
|
didn't give anything back yet - flush now to avoid
|
|
|
|
buffer underruns */
|
|
|
|
encoder_flush(httpd->encoder, NULL);
|
|
|
|
httpd->unflushed_input = 0;
|
|
|
|
}
|
|
|
|
|
2012-10-01 23:52:40 +02:00
|
|
|
size_t size = 0;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
do {
|
2012-10-01 23:52:40 +02:00
|
|
|
size_t nbytes = encoder_read(httpd->encoder,
|
|
|
|
httpd->buffer + size,
|
|
|
|
sizeof(httpd->buffer) - size);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
if (nbytes == 0)
|
|
|
|
break;
|
|
|
|
|
2010-08-06 22:18:01 +02:00
|
|
|
httpd->unflushed_input = 0;
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
size += nbytes;
|
|
|
|
} while (size < sizeof(httpd->buffer));
|
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return page_new_copy(httpd->buffer, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_encoder_open(httpd_output *httpd,
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
struct audio_format *audio_format,
|
|
|
|
GError **error)
|
|
|
|
{
|
2012-10-01 23:52:40 +02:00
|
|
|
if (!encoder_open(httpd->encoder, audio_format, error))
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* we have to remember the encoder header, i.e. the first
|
|
|
|
bytes of encoder output after opening it, because it has to
|
|
|
|
be sent to every new client */
|
|
|
|
httpd->header = httpd_output_read_page(httpd);
|
2010-08-06 22:18:01 +02:00
|
|
|
|
|
|
|
httpd->unflushed_input = 0;
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_enable(struct audio_output *ao, GError **error_r)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2009-11-07 16:52:44 +01:00
|
|
|
return httpd_output_bind(httpd, error_r);
|
2009-11-05 23:47:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_disable(struct audio_output *ao)
|
2009-11-05 23:47:29 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
2009-11-05 23:47:29 +01:00
|
|
|
|
2009-11-07 16:52:44 +01:00
|
|
|
httpd_output_unbind(httpd);
|
2009-11-05 23:47:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_open(struct audio_output *ao, struct audio_format *audio_format,
|
2009-11-05 23:47:29 +01:00
|
|
|
GError **error)
|
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
|
|
|
|
|
|
|
assert(httpd->clients.empty());
|
2009-11-05 23:47:29 +01:00
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
2009-11-05 23:47:29 +01:00
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
/* open the encoder */
|
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
if (!httpd_output_encoder_open(httpd, audio_format, error))
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* initialize other attributes */
|
|
|
|
|
2009-10-29 22:38:18 +01:00
|
|
|
httpd->clients_cnt = 0;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
httpd->timer = timer_new(audio_format);
|
|
|
|
|
2009-11-05 23:47:29 +01:00
|
|
|
httpd->open = true;
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-09-16 23:31:48 +02:00
|
|
|
static void
|
|
|
|
httpd_output_close(struct audio_output *ao)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2009-11-05 23:47:29 +01:00
|
|
|
httpd->open = false;
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
timer_free(httpd->timer);
|
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd->clients.clear();
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
|
|
|
if (httpd->header != NULL)
|
|
|
|
page_unref(httpd->header);
|
|
|
|
|
|
|
|
encoder_close(httpd->encoder);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_remove_client(httpd_output *httpd, HttpdClient *client)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
|
|
|
assert(httpd != NULL);
|
2013-01-15 18:22:17 +01:00
|
|
|
assert(httpd->clients_cnt > 0);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
assert(client != NULL);
|
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
for (auto prev = httpd->clients.before_begin(), i = std::next(prev);;
|
|
|
|
prev = i, i = std::next(prev)) {
|
|
|
|
assert(i != httpd->clients.end());
|
|
|
|
if (&*i == client) {
|
|
|
|
httpd->clients.erase_after(prev);
|
|
|
|
httpd->clients_cnt--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_send_header(httpd_output *httpd, HttpdClient *client)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
|
|
|
if (httpd->header != NULL)
|
2013-01-15 18:22:17 +01:00
|
|
|
client->PushPage(httpd->header);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
2010-11-05 09:42:14 +01:00
|
|
|
static unsigned
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_delay(struct audio_output *ao)
|
2010-11-05 09:42:14 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
2010-11-05 09:42:14 +01:00
|
|
|
|
2012-08-14 21:39:33 +02:00
|
|
|
if (!httpd_output_lock_has_clients(httpd) && httpd->base.pause) {
|
|
|
|
/* if there's no client and this output is paused,
|
|
|
|
then httpd_output_pause() will not do anything, it
|
|
|
|
will not fill the buffer and it will not update the
|
|
|
|
timer; therefore, we reset the timer here */
|
|
|
|
timer_reset(httpd->timer);
|
2012-08-14 21:46:43 +02:00
|
|
|
|
|
|
|
/* some arbitrary delay that is long enough to avoid
|
|
|
|
consuming too much CPU, and short enough to notice
|
|
|
|
new clients quickly enough */
|
|
|
|
return 1000;
|
2012-08-14 21:39:33 +02:00
|
|
|
}
|
|
|
|
|
2010-11-05 09:42:14 +01:00
|
|
|
return httpd->timer->started
|
|
|
|
? timer_delay(httpd->timer)
|
|
|
|
: 0;
|
|
|
|
}
|
|
|
|
|
2009-05-05 22:43:28 +02:00
|
|
|
/**
|
|
|
|
* Broadcasts a page struct to all clients.
|
|
|
|
*/
|
|
|
|
static void
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_broadcast_page(httpd_output *httpd, struct page *page)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2009-05-05 22:43:28 +02:00
|
|
|
assert(page != NULL);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
|
|
|
for (auto &client : httpd->clients)
|
|
|
|
client.PushPage(page);
|
2009-05-05 22:43:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Broadcasts data from the encoder to all clients.
|
|
|
|
*/
|
|
|
|
static void
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_encoder_to_clients(httpd_output *httpd)
|
2009-05-05 22:43:28 +02:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd->mutex.lock();
|
|
|
|
for (auto &client : httpd->clients) {
|
|
|
|
if (client.GetQueueSize() > 256 * 1024) {
|
|
|
|
g_debug("client is too slow, flushing its queue");
|
|
|
|
client.CancelQueue();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
httpd->mutex.unlock();
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
struct page *page;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
while ((page = httpd_output_read_page(httpd)) != NULL) {
|
2009-05-05 22:43:28 +02:00
|
|
|
httpd_output_broadcast_page(httpd, page);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
page_unref(page);
|
|
|
|
}
|
2009-05-05 22:43:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output_encode_and_play(httpd_output *httpd,
|
2009-05-05 22:43:28 +02:00
|
|
|
const void *chunk, size_t size, GError **error)
|
|
|
|
{
|
2012-10-01 23:52:40 +02:00
|
|
|
if (!encoder_write(httpd->encoder, chunk, size, error))
|
2009-05-05 22:43:28 +02:00
|
|
|
return false;
|
|
|
|
|
2010-08-06 22:18:01 +02:00
|
|
|
httpd->unflushed_input += size;
|
|
|
|
|
2009-05-05 22:43:28 +02:00
|
|
|
httpd_output_encoder_to_clients(httpd);
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_play(struct audio_output *ao, const void *chunk, size_t size,
|
2012-10-01 23:52:40 +02:00
|
|
|
GError **error_r)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2012-08-14 20:22:32 +02:00
|
|
|
if (httpd_output_lock_has_clients(httpd)) {
|
2012-10-01 23:52:40 +02:00
|
|
|
if (!httpd_output_encode_and_play(httpd, chunk, size, error_r))
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!httpd->timer->started)
|
|
|
|
timer_start(httpd->timer);
|
|
|
|
timer_add(httpd->timer, size);
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2010-08-06 07:23:17 +02:00
|
|
|
static bool
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_pause(struct audio_output *ao)
|
2010-08-06 07:23:17 +02:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
2010-08-06 07:23:17 +02:00
|
|
|
|
2012-08-14 20:22:32 +02:00
|
|
|
if (httpd_output_lock_has_clients(httpd)) {
|
2013-01-15 18:22:17 +01:00
|
|
|
static const char silence[1020] = { 0 };
|
2011-09-16 23:31:48 +02:00
|
|
|
return httpd_output_play(ao, silence, sizeof(silence),
|
2011-07-20 19:16:47 +02:00
|
|
|
NULL) > 0;
|
2010-08-06 07:23:17 +02:00
|
|
|
} else {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_tag(struct audio_output *ao, const struct tag *tag)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2009-05-05 22:36:44 +02:00
|
|
|
assert(tag != NULL);
|
|
|
|
|
2009-05-05 22:41:36 +02:00
|
|
|
if (httpd->encoder->plugin->tag != NULL) {
|
|
|
|
/* embed encoder tags */
|
2009-05-05 22:51:17 +02:00
|
|
|
|
|
|
|
/* flush the current stream, and end it */
|
|
|
|
|
2011-07-20 20:54:34 +02:00
|
|
|
encoder_pre_tag(httpd->encoder, NULL);
|
2009-05-05 22:51:17 +02:00
|
|
|
httpd_output_encoder_to_clients(httpd);
|
|
|
|
|
|
|
|
/* send the tag to the encoder - which starts a new
|
|
|
|
stream now */
|
2009-05-05 22:41:36 +02:00
|
|
|
|
|
|
|
encoder_tag(httpd->encoder, tag, NULL);
|
2009-05-05 22:51:17 +02:00
|
|
|
|
|
|
|
/* the first page generated by the encoder will now be
|
|
|
|
used as the new "header" page, which is sent to all
|
|
|
|
new clients */
|
|
|
|
|
2012-10-01 23:52:40 +02:00
|
|
|
struct page *page = httpd_output_read_page(httpd);
|
2009-05-05 22:51:17 +02:00
|
|
|
if (page != NULL) {
|
|
|
|
if (httpd->header != NULL)
|
|
|
|
page_unref(httpd->header);
|
|
|
|
httpd->header = page;
|
|
|
|
httpd_output_broadcast_page(httpd, page);
|
|
|
|
}
|
2009-05-05 22:41:36 +02:00
|
|
|
} else {
|
|
|
|
/* use Icy-Metadata */
|
|
|
|
|
|
|
|
if (httpd->metadata != NULL)
|
|
|
|
page_unref (httpd->metadata);
|
|
|
|
|
|
|
|
httpd->metadata =
|
2009-10-13 16:12:45 +02:00
|
|
|
icy_server_metadata_page(tag, TAG_ALBUM,
|
|
|
|
TAG_ARTIST, TAG_TITLE,
|
2009-05-05 22:41:36 +02:00
|
|
|
TAG_NUM_OF_ITEM_TYPES);
|
|
|
|
if (httpd->metadata != NULL) {
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
|
|
|
for (auto &client : httpd->clients)
|
|
|
|
client.PushMetaData(httpd->metadata);
|
2009-05-05 22:41:36 +02:00
|
|
|
}
|
2009-04-13 19:35:02 +02:00
|
|
|
}
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
httpd_output_cancel(struct audio_output *ao)
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
{
|
2013-01-15 18:22:17 +01:00
|
|
|
httpd_output *httpd = (httpd_output *)ao;
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
|
2013-01-15 18:22:17 +01:00
|
|
|
const ScopeLock protect(httpd->mutex);
|
|
|
|
for (auto &client : httpd->clients)
|
|
|
|
client.CancelQueue();
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
const struct audio_output_plugin httpd_output_plugin = {
|
2013-01-15 18:22:17 +01:00
|
|
|
"httpd",
|
|
|
|
nullptr,
|
|
|
|
httpd_output_init,
|
|
|
|
httpd_output_finish,
|
|
|
|
httpd_output_enable,
|
|
|
|
httpd_output_disable,
|
|
|
|
httpd_output_open,
|
|
|
|
httpd_output_close,
|
|
|
|
httpd_output_delay,
|
|
|
|
httpd_output_tag,
|
|
|
|
httpd_output_play,
|
|
|
|
nullptr,
|
|
|
|
httpd_output_cancel,
|
|
|
|
httpd_output_pause,
|
|
|
|
nullptr,
|
httpd: new output plugin to replace "shout"
Let's get rid of the "shout" plugin, and the awfully complicated
icecast daemon setup! MPD can do better if it's doing the HTTP server
stuff on its own. This new plugin has several advantages:
- easier to set up - only one daemon, no password settings, no mount
settings
- MPD controls the encoder and thus already knows the packet
boundaries - icecast has to parse them
- MPD doesn't bother to encode data while nobody is listening
This implementation is very experimental (no header parsing, ignores
request URI, no icy-metadata, ...). It should be able to suport
several encoders in parallel in the future (with different bit rates,
different codec, ...), to make MPD the perfect streaming server. Once
MPD gets multi-player support, we can even mount several different
radio stations on one server.
2009-03-15 03:32:34 +01:00
|
|
|
};
|