/*
AudioFileSourceICYStream
Streaming Shoutcast ICY source
Copyright (C) 2017 Earle F. Philhower, III
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
#include "AudioFileSourceICYStream.h"
AudioFileSourceICYStream::AudioFileSourceICYStream()
{
pos = 0;
reconnectTries = 0;
saveURL = NULL;
}
AudioFileSourceICYStream::AudioFileSourceICYStream(const char *url)
{
saveURL = NULL;
reconnectTries = 0;
open(url);
}
bool AudioFileSourceICYStream::open(const char *url)
{
static const char *hdr[] = { "icy-metaint" };
pos = 0;
http.begin(url);
http.addHeader("Icy-MetaData", "1");
http.collectHeaders( hdr, 1 );
http.setReuse(true);
int code = http.GET();
if (code != HTTP_CODE_OK) {
http.end();
cb.st(STATUS_HTTPFAIL, PSTR("Can't open HTTP request"));
return false;
}
if (http.hasHeader(hdr[0])) {
String ret = http.header(hdr[0]);
icyMetaInt = ret.toInt();
} else {
icyMetaInt = 0;
}
icyByteCount = 0;
size = http.getSize();
free(saveURL);
saveURL = strdup(url);
return true;
}
AudioFileSourceICYStream::~AudioFileSourceICYStream()
{
http.end();
}
class ICYMDReader {
public:
ICYMDReader(WiFiClient *str, uint16_t bytes) {
stream = str;
avail = bytes;
ptr = sizeof(buff)+1; // Cause read next time
saved = -1;
}
~ICYMDReader() {
// Get rid of any remaining bytes in the MD block
char xxx[16];
if (saved) avail--; // Throw away any unread bytes
while (avail > 16) {
stream->readBytes(xxx, 16);
avail -= 16;
}
stream->readBytes(xxx, avail);
}
int read(uint8_t *dest, int len) {
if (!len) return 0;
int ret = 0;
if (saved >= 0) { *(dest++) = (uint8_t)saved; saved = -1; len--; avail--; ret++; }
while ((len>0) && (avail>0)) {
// Always copy from bounce buffer first
while ((ptr < sizeof(buff)) && (len>0) && (avail>0)) {
*(dest++) = buff[ptr++];
avail--;
ret++;
len--;
}
// refill the bounce buffer
if ((avail>0) && (len>0)) {
ptr = 0;
int toRead = (sizeof(buff)>avail)? avail : sizeof(buff);
int read = stream->readBytes(buff, toRead);
if (read != toRead) return 0; // Error, short read!
}
}
return ret;
}
bool eof() { return (avail==0); }
bool unread(uint8_t c) { if (saved>=0) return false; saved = c; avail++; return true; }
private:
WiFiClient *stream;
uint16_t avail;
uint8_t ptr;
uint8_t buff[16];
int saved;
};
uint32_t AudioFileSourceICYStream::readInternal(void *data, uint32_t len, bool nonBlock)
{
retry:
if (!http.connected()) {
cb.st(STATUS_DISCONNECTED, PSTR("Stream disconnected"));
http.end();
for (int i = 0; i < reconnectTries; i++) {
char buff[32];
sprintf_P(buff, PSTR("Attempting to reconnect, try %d"), i);
cb.st(STATUS_RECONNECTING, buff);
delay(reconnectDelayMs);
if (open(saveURL)) {
cb.st(STATUS_RECONNECTED, PSTR("Stream reconnected"));
break;
}
}
if (!http.connected()) {
cb.st(STATUS_DISCONNECTED, PSTR("Unable to reconnect"));
return 0;
}
}
if ((size > 0) && (pos >= size)) return 0;
WiFiClient *stream = http.getStreamPtr();
// Can't read past EOF...
if ( (size > 0) && (len > (uint32_t)(pos - size)) ) len = pos - size;
if (!nonBlock) {
int start = millis();
while ((stream->available() < (int)len) && (millis() - start < 500)) yield();
}
size_t avail = stream->available();
if (!nonBlock && !avail) {
cb.st(STATUS_NODATA, PSTR("No stream data available"));
http.end();
goto retry;
}
if (avail == 0) return 0;
if (avail < len) len = avail;
int read = 0;
// If the read would hit an ICY block, split it up...
if (((int)(icyByteCount + len) > (int)icyMetaInt) && (icyMetaInt > 0)) {
int beforeIcy = icyMetaInt - icyByteCount;
int ret = stream->readBytes(reinterpret_cast(data), beforeIcy);
read += ret;
pos += ret;
len -= ret;
data = (void *)(reinterpret_cast(data) + ret);
icyByteCount += ret;
if (ret != beforeIcy) return read; // Partial read
uint8_t mdSize;
int mdret = stream->readBytes(&mdSize, 1);
if ((mdret == 1) && (mdSize > 0)) {
ICYMDReader mdr(stream, mdSize * 16);
// Break out (potentially multiple) NAME='xxxx'
char type[32];
char value[64];
while (!mdr.eof()) {
memset(type, 0, sizeof(type));
memset(value, 0, sizeof(value));
uint8_t c;
char *p = type;
for (size_t i=0; ireadBytes(reinterpret_cast(data), len);
read += ret;
pos += ret;
icyByteCount += ret;
return read;
}