2 * Sonitus - Icecast2Sink.java - Copyright © 2013 David Roden
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 package net.pterodactylus.sonitus.data.sink;
20 import java.io.IOException;
21 import java.io.InputStream;
22 import java.io.OutputStream;
23 import java.io.UnsupportedEncodingException;
24 import java.net.Socket;
25 import java.net.URLEncoder;
26 import java.util.Arrays;
27 import java.util.Collections;
28 import java.util.List;
29 import java.util.logging.Level;
30 import java.util.logging.Logger;
32 import net.pterodactylus.sonitus.data.Controller;
33 import net.pterodactylus.sonitus.data.Metadata;
34 import net.pterodactylus.sonitus.data.Sink;
35 import net.pterodactylus.sonitus.io.InputStreamDrainer;
37 import com.google.common.base.Function;
38 import com.google.common.base.Joiner;
39 import com.google.common.base.Optional;
40 import com.google.common.collect.FluentIterable;
41 import com.google.common.eventbus.EventBus;
42 import com.google.common.io.BaseEncoding;
43 import com.google.common.io.Closeables;
46 * {@link net.pterodactylus.sonitus.data.Sink} implementation that delivers all
47 * incoming data to an Icecast2 server.
49 * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
51 public class Icecast2Sink implements Sink {
54 private static final Logger logger = Logger.getLogger(Icecast2Sink.class.getName());
57 private final EventBus eventBus;
59 /** The server name. */
60 private final String server;
62 /** The port number on the server. */
63 private final int port;
65 /** The source password. */
66 private final String password;
68 /** The stream mount point (without leading slash). */
69 private final String mountPoint;
71 /** The name of the server. */
72 private final String serverName;
74 /** The description of the server. */
75 private final String serverDescription;
77 /** The genre of the server. */
78 private final String genre;
80 /** Whether to publish the server. */
81 private final boolean publishServer;
83 private OutputStream socketOutputStream;
85 /** The current metadata. */
86 private Metadata metadata;
89 * Creates a new Icecast2 sink.
94 * The hostname of the server
96 * The port number of the server
100 * The stream mount point
102 * The name of the server
103 * @param serverDescription
104 * The description of the server
106 * The genre of the server
107 * @param publishServer
108 * {@code true} to publish the server in a public directory, {@code false} to
111 public Icecast2Sink(EventBus eventBus, String server, int port, String password, String mountPoint, String serverName, String serverDescription, String genre, boolean publishServer) {
112 this.eventBus = eventBus;
113 this.server = server;
115 this.password = password;
116 this.mountPoint = mountPoint;
117 this.serverName = serverName;
118 this.serverDescription = serverDescription;
120 this.publishServer = publishServer;
124 // CONTROLLED METHODS
128 public String name() {
129 return String.format("icecast://%s:%d/%s", server, port, mountPoint);
133 public Metadata metadata() {
138 public List<Controller<?>> controllers() {
139 return Collections.emptyList();
147 public void open(Metadata metadata) throws IOException {
148 logger.info(String.format("Connecting to %s:%d...", server, port));
149 Socket socket = new Socket(server, port);
150 logger.info("Connected.");
151 socketOutputStream = socket.getOutputStream();
152 InputStream socketInputStream = socket.getInputStream();
154 sendLine(socketOutputStream, String.format("SOURCE /%s ICE/1.0", mountPoint));
155 sendLine(socketOutputStream, String.format("Authorization: Basic %s", generatePassword(password)));
156 sendLine(socketOutputStream, String.format("Content-Type: %s", getContentType(metadata)));
157 sendLine(socketOutputStream, String.format("ICE-Name: %s", serverName));
158 sendLine(socketOutputStream, String.format("ICE-Description: %s", serverDescription));
159 sendLine(socketOutputStream, String.format("ICE-Genre: %s", genre));
160 sendLine(socketOutputStream, String.format("ICE-Public: %d", publishServer ? 1 : 0));
161 sendLine(socketOutputStream, "");
162 socketOutputStream.flush();
164 new Thread(new InputStreamDrainer(socketInputStream)).start();
166 metadataUpdated(metadata);
170 public void close() {
172 Closeables.close(socketOutputStream, true);
173 } catch (IOException e) {
174 /* will never throw. */
179 public void metadataUpdated(final Metadata metadata) {
180 this.metadata = metadata;
181 new Thread(new Runnable() {
185 String metadataString = String.format("%s (%s)", Joiner.on(" - ").skipNulls().join(FluentIterable.from(Arrays.asList(metadata.artist(), metadata.name())).transform(new Function<Optional<String>, Object>() {
188 public Object apply(Optional<String> input) {
189 return input.orNull();
192 logger.info(String.format("Updating metadata to %s", metadataString));
194 Socket socket = null;
195 OutputStream socketOutputStream = null;
197 socket = new Socket(server, port);
198 socketOutputStream = socket.getOutputStream();
200 sendLine(socketOutputStream, String.format("GET /admin/metadata?pass=%s&mode=updinfo&mount=/%s&song=%s HTTP/1.0", password, mountPoint, URLEncoder.encode(metadataString, "UTF-8")));
201 sendLine(socketOutputStream, String.format("Authorization: Basic %s", generatePassword(password)));
202 sendLine(socketOutputStream, String.format("User-Agent: Mozilla/Sonitus"));
203 sendLine(socketOutputStream, "");
204 socketOutputStream.flush();
206 new InputStreamDrainer(socket.getInputStream()).run();
207 } catch (IOException ioe1) {
208 logger.log(Level.WARNING, "Could not update metadata!", ioe1);
211 Closeables.close(socketOutputStream, true);
212 if (socket != null) {
215 } catch (IOException ioe1) {
224 public void process(byte[] buffer) throws IOException {
225 socketOutputStream.write(buffer);
226 socketOutputStream.flush();
234 * Sends the given line, followed by CR+LF, to the given output stream,
235 * encoding the complete line as UTF-8.
237 * @param outputStream
238 * The output stream to send the line to
241 * @throws java.io.IOException
242 * if an I/O error occurs
244 private static void sendLine(OutputStream outputStream, String line) throws IOException {
245 outputStream.write((line + "\r\n").getBytes("UTF-8"));
249 * Generates the Base64-encoded authorization information from the given
250 * password. A fixed username of “source” is used.
253 * The password to encode
254 * @return The encoded password
255 * @throws java.io.UnsupportedEncodingException
256 * if the UTF-8 encoding is not supported (which can never happen)
258 private static String generatePassword(String password) throws UnsupportedEncodingException {
259 return BaseEncoding.base64().encode(("source:" + password).getBytes("UTF-8"));
263 * Returns a MIME type for the given metadata. Currently only Vorbis, MP3, PCM,
264 * Ogg Vorbis, Opus, and FLAC formats are recognized.
267 * The metadata to get a MIME type for
268 * @return The MIME type of the metadata
270 private static String getContentType(Metadata metadata) {
271 String encoding = metadata.encoding();
272 if ("Vorbis".equalsIgnoreCase(encoding)) {
275 if ("MP3".equalsIgnoreCase(encoding)) {
278 if ("PCM".equalsIgnoreCase(encoding)) {
279 return "audio/vnd.wave";
281 if ("Vorbis".equalsIgnoreCase(encoding)) {
282 return "application/ogg";
284 if ("Opus".equalsIgnoreCase(encoding)) {
285 return "audio/ogg; codecs=opus";
287 if ("FLAC".equalsIgnoreCase(encoding)) {
290 return "application/octet-stream";