From eb9244f20210fd420fb9b3c98126f9cae525d1cc Mon Sep 17 00:00:00 2001 From: Marvin Scholz Date: Mon, 28 Jul 2014 11:55:38 +0200 Subject: Add Icecast protocol MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Icecast is basically a convenience wrapper around the HTTP protocol. Signed-off-by: Martin Storsjö --- libavformat/icecast.c | 228 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 libavformat/icecast.c (limited to 'libavformat/icecast.c') diff --git a/libavformat/icecast.c b/libavformat/icecast.c new file mode 100644 index 0000000000..b671d8ced9 --- /dev/null +++ b/libavformat/icecast.c @@ -0,0 +1,228 @@ +/* + * Icecast protocol for Libav + * Copyright (c) 2014 Marvin Scholz + * + * This file is part of Libav. + * + * Libav is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Libav 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + + +#include "libavutil/avstring.h" +#include "libavutil/opt.h" + +#include "avformat.h" +#include "network.h" + + +typedef struct IcecastContext { + const AVClass *class; + URLContext *hd; + int send_started; + char *user; + // Options + char *content_type; + char *description; + char *genre; + int legacy_icecast; + char *name; + char *pass; + int public; + char *url; + char *user_agent; +} IcecastContext; + +#define DEFAULT_ICE_USER "source" + +#define NOT_EMPTY(s) (s && s[0]) + +#define OFFSET(x) offsetof(IcecastContext, x) +#define E AV_OPT_FLAG_ENCODING_PARAM + +static const AVOption options[] = { + { "ice_genre", "set stream genre", OFFSET(genre), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "ice_name", "set stream description", OFFSET(name), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "ice_description", "set stream description", OFFSET(description), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "ice_url", "set stream website", OFFSET(url), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "ice_public", "set if stream is public", OFFSET(public), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E }, + { "user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "password", "set password", OFFSET(pass), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "content_type", "set content-type, MUST be set if not audio/mpeg", OFFSET(content_type), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E }, + { "legacy_icecast", "use legacy SOURCE method, for Icecast < v2.4", OFFSET(legacy_icecast), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E }, + { NULL } +}; + + +static char *cat_header(char buf[], const char key[], const char value[]) +{ + if (NOT_EMPTY(value)) { + int len = strlen(key) + strlen(value) + 5; + int is_first = !buf; + char *tmp = NULL; + + if (buf) + len += strlen(buf); + if (!(tmp = av_realloc(buf, len))) { + av_freep(&buf); + return NULL; + } else { + buf = tmp; + } + if (is_first) + *buf = '\0'; + + av_strlcatf(buf, len, "%s: %s\r\n", key, value); + } + return buf; +} + +static int icecast_close(URLContext *h) +{ + IcecastContext *s = h->priv_data; + if (s->hd) + ffurl_close(s->hd); + return 0; +} + +static int icecast_open(URLContext *h, const char *uri, int flags) +{ + IcecastContext *s = h->priv_data; + + // Dict to set options that we pass to the HTTP protocol + AVDictionary *opt_dict = NULL; + + // URI part variables + char h_url[1024], host[1024], auth[1024], path[1024]; + char *headers = NULL, *user = NULL; + int port, ret; + + if (flags & AVIO_FLAG_READ) + return AVERROR(ENOSYS); + + // Build header strings + headers = cat_header(headers, "Ice-Name", s->name); + headers = cat_header(headers, "Ice-Description", s->description); + headers = cat_header(headers, "Ice-URL", s->url); + headers = cat_header(headers, "Ice-Genre", s->genre); + headers = cat_header(headers, "Ice-Public", s->public ? "1" : "0"); + if (!headers) { + ret = AVERROR(ENOMEM); + goto cleanup; + } + + // Set options + av_dict_set(&opt_dict, "method", s->legacy_icecast ? "SOURCE" : "PUT", 0); + av_dict_set(&opt_dict, "auth_type", "basic", 0); + av_dict_set(&opt_dict, "headers", headers, 0); + if (NOT_EMPTY(s->content_type)) + av_dict_set(&opt_dict, "content_type", s->content_type, 0); + if (NOT_EMPTY(s->user_agent)) + av_dict_set(&opt_dict, "user_agent", s->user_agent, 0); + + // Parse URI + av_url_split(NULL, 0, auth, sizeof(auth), host, sizeof(host), + &port, path, sizeof(path), uri); + + // Check for auth data in URI + if (auth[0]) { + char *sep = strchr(auth,':'); + if (sep) { + *sep = 0; + sep++; + if (s->pass) { + av_free(s->pass); + av_log(h, AV_LOG_WARNING, "Overwriting -password with URI password!\n"); + } + if (!(s->pass = av_strdup(sep))) { + ret = AVERROR(ENOMEM); + goto cleanup; + } + } + if (!(user = av_strdup(auth))) { + ret = AVERROR(ENOMEM); + goto cleanup; + } + } + + // Build new authstring + snprintf(auth, sizeof(auth), + "%s:%s", + user ? user : DEFAULT_ICE_USER, + s->pass ? s->pass : ""); + + // Check for mountpoint (path) + if (!path[0] || strcmp(path, "/") == 0) { + av_log(h, AV_LOG_ERROR, "No mountpoint (path) specified!\n"); + ret = AVERROR(EIO); + goto cleanup; + } + + // Build new URI for passing to http protocol + ff_url_join(h_url, sizeof(h_url), "http", auth, host, port, "%s", path); + // Finally open http proto handler + ret = ffurl_open(&s->hd, h_url, AVIO_FLAG_READ_WRITE, NULL, &opt_dict); + +cleanup: + // Free variables + av_freep(&user); + av_freep(&headers); + av_dict_free(&opt_dict); + + return ret; +} + +static int icecast_write(URLContext *h, const uint8_t *buf, int size) +{ + IcecastContext *s = h->priv_data; + if (!s->send_started) { + s->send_started = 1; + if (!s->content_type && size >= 8) { + static const uint8_t oggs[4] = { 0x4F, 0x67, 0x67, 0x53 }; + static const uint8_t webm[4] = { 0x1A, 0x45, 0xDF, 0xA3 }; + static const uint8_t opus[8] = { 0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64 }; + if (memcmp(buf, oggs, sizeof(oggs)) == 0) { + av_log(h, AV_LOG_WARNING, "Streaming Ogg but appropriate content type NOT set!\n"); + av_log(h, AV_LOG_WARNING, "Set it with -content_type application/ogg\n"); + } else if (memcmp(buf, opus, sizeof(opus)) == 0) { + av_log(h, AV_LOG_WARNING, "Streaming Opus but appropriate content type NOT set!\n"); + av_log(h, AV_LOG_WARNING, "Set it with -content_type audio/ogg\n"); + } else if (memcmp(buf, webm, sizeof(webm)) == 0) { + av_log(h, AV_LOG_WARNING, "Streaming WebM but appropriate content type NOT set!\n"); + av_log(h, AV_LOG_WARNING, "Set it with -content_type video/webm\n"); + } else { + av_log(h, AV_LOG_WARNING, "It seems you are streaming an unsupported format.\n"); + av_log(h, AV_LOG_WARNING, "It might work, but is not officially supported in Icecast!\n"); + } + } + } + return ffurl_write(s->hd, buf, size); +} + +static const AVClass icecast_context_class = { + .class_name = "icecast", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +URLProtocol ff_icecast_protocol = { + .name = "icecast", + .url_open = icecast_open, + .url_write = icecast_write, + .url_close = icecast_close, + .priv_data_size = sizeof(IcecastContext), + .priv_data_class = &icecast_context_class, + .flags = URL_PROTOCOL_FLAG_NETWORK, +}; -- cgit v1.2.3