int main (int argc, char *argv[])
{
double estimatedBitRate;
FILE *fp;
if(argc < 2)
{
printf("Usage: %s <transport stream file>\n", argv[0]);
exit(-1);
}
if((fp = fopen(argv[1],"r+b")) == NULL)
{
perror("failure on MPEG-2 TS file open");
exit(-1);
}
else
{
printf("opened %s\n", argv[1]);
}
estimatedBitRate=getBitRate(fp);
//printf("estimatedBitRate=%lf\n", estimatedBitRate);
fclose(fp);
return OK;
}
/* refresh MP3 size with new bitrate */
static void refreshFieldInfo(HWND hwnd, LONG id)
{
CDTRACKRECORD *record;
USHORT bitrate = getBitRate();
record = (CDTRACKRECORD *) enumRecords(hwnd, id, NULL, CMA_FIRST);
while(record && record != (CDTRACKRECORD *) -1)
{
if(!bitrate)
record->mp3size = 0;
else if(!record->data)
record->mp3size = record->size /
((record->channels*2*44100) / ((double) getBitRate() * 1000/8)) + 0.5;
record = (CDTRACKRECORD *) enumRecords(hwnd, id, (RECORDCORE *) record, CMA_NEXT);
}
WinSendDlgItemMsg(hwnd, id, CM_INVALIDATEDETAILFIELDINFO,0,0);
}
/*------------------------------------------------------------------------------
* Log in to the IceCast2 server
*----------------------------------------------------------------------------*/
bool
IceCast2 :: sendLogin ( void ) throw ( Exception )
{
Sink * sink = getSink();
Source * source = getSocket();
const char * str;
char resp[STRBUF_SIZE];
unsigned int len;
unsigned int lenExpected;
if ( !source->isOpen() ) {
return false;
}
if ( !sink->isOpen() ) {
return false;
}
// send the request, a string like:
// "SOURCE <mountpoint> ICE/1.0"
str = "SOURCE /";
sink->write( str, strlen( str));
str = getMountPoint();
sink->write( str, strlen( str));
str = " HTTP/1.0";
sink->write( str, strlen( str));
// send the content type, Ogg Vorbis
str = "\nContent-type: ";
sink->write( str, strlen( str));
switch ( format ) {
case mp3:
str = "audio/mpeg";
break;
case oggVorbis:
str = "application/x-ogg";
break;
default:
throw Exception( __FILE__, __LINE__,
"unsupported stream format", format);
break;
}
sink->write( str, strlen( str));
// send the authentication info
str = "\nAuthorization: Basic ";
sink->write( str, strlen(str));
{
// send source:<password> encoded as base64
char * source = "source:";
const char * pwd = getPassword();
char * tmp = new char[Util::strLen(source) +
Util::strLen(pwd) + 1];
Util::strCpy( tmp, source);
Util::strCat( tmp, pwd);
char * base64 = Util::base64Encode( tmp);
delete[] tmp;
sink->write( base64, strlen(base64));
delete[] base64;
}
// send user agent info
str = "\nUser-Agent: DarkIce/" VERSION " (http://darkice.sourceforge.net/)";
sink->write( str, strlen( str));
// send the ice- headers
str = "\nice-bitrate: ";
sink->write( str, strlen( str));
if ( log10(getBitRate()) >= (STRBUF_SIZE-2) ) {
throw Exception( __FILE__, __LINE__,
"bitrate does not fit string buffer", getBitRate());
}
sprintf( resp, "%d", getBitRate());
sink->write( resp, strlen( resp));
str = "\nice-public: ";
sink->write( str, strlen( str));
str = getIsPublic() ? "1" : "0";
sink->write( str, strlen( str));
if ( getName() ) {
str = "\nice-name: ";
sink->write( str, strlen( str));
str = getName();
sink->write( str, strlen( str));
}
if ( getDescription() ) {
str = "\nice-description: ";
sink->write( str, strlen( str));
str = getDescription();
sink->write( str, strlen( str));
}
if ( getUrl() ) {
str = "\nice-url: ";
sink->write( str, strlen( str));
str = getUrl();
sink->write( str, strlen( str));
}
if ( getGenre() ) {
str = "\nice-genre: ";
sink->write( str, strlen( str));
str = getGenre();
sink->write( str, strlen( str));
}
str = "\n\n";
sink->write( str, strlen( str));
sink->flush();
// read the response, expected response begins with responseOK
lenExpected = Util::strLen( responseOK);
if ( (len = source->read( resp, STRBUF_SIZE-1)) < lenExpected ) {
return false;
}
resp[lenExpected] = 0;
if ( !Util::strEq( resp, responseOK) ) {
return false;
}
// suck anything that the other side has to say
while ( source->canRead( 0, 0) &&
(len = source->read( resp, STRBUF_SIZE-1)) );
return true;
}
/*------------------------------------------------------------------------------
* Log in to the IceCast server
*----------------------------------------------------------------------------*/
bool
IceCast :: sendLogin ( void ) throw ( Exception )
{
Sink * sink = getSink();
Source * source = getSocket();
const char * str;
char resp[STRBUF_SIZE];
unsigned int len;
if ( !source->isOpen() ) {
return false;
}
if ( !sink->isOpen() ) {
return false;
}
/* send the request, a string like:
* "SOURCE <password> /<mountpoint>\n" */
str = "SOURCE ";
sink->write( str, strlen( str));
str = getPassword();
sink->write( str, strlen( str));
str = " /";
sink->write( str, strlen( str));
str = getMountPoint();
sink->write( str, strlen( str));
/* send the x-audiocast headers */
str = "\nx-audiocast-bitrate: ";
sink->write( str, strlen( str));
if ( log10(getBitRate()) >= (STRBUF_SIZE-2) ) {
throw Exception( __FILE__, __LINE__,
"bitrate does not fit string buffer", getBitRate());
}
sprintf( resp, "%d", getBitRate());
sink->write( resp, strlen( resp));
str = "\nx-audiocast-public: ";
sink->write( str, strlen( str));
str = getIsPublic() ? "1" : "0";
sink->write( str, strlen( str));
if ( getName() ) {
str = "\nx-audiocast-name: ";
sink->write( str, strlen( str));
str = getName();
sink->write( str, strlen( str));
}
if ( getDescription() ) {
str = "\nx-audiocast-description: ";
sink->write( str, strlen( str));
str = getDescription();
sink->write( str, strlen( str));
}
if ( getUrl() ) {
str = "\nx-audiocast-url: ";
sink->write( str, strlen( str));
str = getUrl();
sink->write( str, strlen( str));
}
if ( getGenre() ) {
str = "\nx-audiocast-genre: ";
sink->write( str, strlen( str));
str = getGenre();
sink->write( str, strlen( str));
}
if ( getRemoteDumpFile() ) {
str = "\nx-audiocast-dumpfile: ";
sink->write( str, strlen( str));
str = getRemoteDumpFile();
sink->write( str, strlen( str));
}
str = "\n\n";
sink->write( str, strlen( str));
sink->flush();
/* read the anticipated response: "OK" */
len = source->read( resp, STRBUF_SIZE);
if ( len < 2 || resp[0] != 'O' || resp[1] != 'K' ) {
return false;
}
/* suck anything that the other side has to say */
while ( source->canRead( 0, 0) &&
(len = source->read( resp, STRBUF_SIZE)) ) {
;
}
return true;
}
void dlgcd_refresh2(void *mp1, void *mp2)
{
int i;
HWND hwnd = (HWND) mp1;
CDTRACKRECORD *record;
CDTRACKRECORD *firstRecord, *posRecord;
RECORDINSERT recordInfo;
char buffer[256];
char buffer2[256];
USHORT bitrate = getBitRate();
if(!cdDrive)
return;
if(cddbSocket)
{
setText(hwnd,EF_ARTIST,cddbSocket->get_disc_title(0));
setText(hwnd,EF_TITLE,cddbSocket->get_disc_title(1));
setText(hwnd,EF_COMMENTS,cddbSocket->get_disc_title(2));
setText(hwnd,EF_GENRE,queryData.category);
}
/* delete all current records */
record = (CDTRACKRECORD *) enumRecords(hwnd, CT_TRACK, NULL, CMA_FIRST);
while(record && record != (CDTRACKRECORD *) -1)
{
free(record->record.pszIcon);
record = (CDTRACKRECORD *) enumRecords(hwnd, CT_TRACK, (RECORDCORE *) record, CMA_NEXT);
}
removeRecords(hwnd, CT_TRACK, NULL, 0);
/* allocate and fill container with CD Track Info */
firstRecord = posRecord = (CDTRACKRECORD *)
allocaRecords(hwnd, CT_TRACK, cdDrive->getCount(), sizeof(CDTRACKRECORD) - sizeof(RECORDCORE));
for (i = 0; i < cdDrive->getCount(); i++)
{
UCHAR track = cdDrive->getCDInfo()->firstTrack+i;
/* setting kludges and other weird things */
posRecord->timepointer = posRecord->time;
posRecord->typepointer = posRecord->type;
posRecord->titleptr = posRecord->title;
posRecord->artistptr = posRecord->artist;
posRecord->albumptr = posRecord->album;
posRecord->yearptr = posRecord->year;
posRecord->genreptr = posRecord->genre;
posRecord->commentptr = posRecord->comment;
posRecord->record.hptrMiniIcon = 0; /* ask God */
/* loading info fields */
if(cdDrive->getTrackInfo(track)->data)
{
strcat(posRecord->time,"N/A");
strcat(posRecord->type,"Data");
posRecord->mp3size = 0;
posRecord->record.hptrIcon = dataIco;
}
else
{
posRecord->minutes = cdDrive->getTrackInfo(track)->length.minute;
posRecord->seconds = cdDrive->getTrackInfo(track)->length.second;
sprintf(posRecord->time,"%d:%.2d",cdDrive->getTrackInfo(track)->length.minute,
cdDrive->getTrackInfo(track)->length.second);
strcat(posRecord->type,"Audio");
if(bitrate)
posRecord->mp3size = cdDrive->getTrackInfo(track)->size /
((cdDrive->getTrackInfo(track)->channels*2*44100) /
((double) bitrate * 1000/8)) + 0.5;
else
posRecord->mp3size = 0;
posRecord->record.hptrIcon = trackIco;
}
posRecord->track = cdDrive->getTrackInfo(track)->number;
posRecord->size = cdDrive->getTrackInfo(track)->size;
posRecord->channels = cdDrive->getTrackInfo(track)->channels;
posRecord->data = cdDrive->getTrackInfo(track)->data;
if(cddbSocket)
{
strncpy(posRecord->title, cddbSocket->get_track_title(i,0), sizeof(posRecord->title)-1);
strncpy(posRecord->artist, cddbSocket->get_disc_title(0), sizeof(posRecord->artist)-1);
strncpy(posRecord->album, cddbSocket->get_disc_title(1), sizeof(posRecord->album)-1);
strncpy(posRecord->comment, cddbSocket->get_track_title(i,1), sizeof(posRecord->comment)-1);
strncpy(posRecord->genre, queryData.category, sizeof(posRecord->genre)-1);
// cddbSocket->get_disc_title(2)
getFilenameFormat(buffer2,sizeof(buffer2));
}
else
{
getText(hwnd,EF_ARTIST,buffer,sizeof(buffer));
strncpy(posRecord->artist, buffer, sizeof(posRecord->artist)-1);
getText(hwnd,EF_TITLE,buffer,sizeof(buffer));
strncpy(posRecord->album, buffer, sizeof(posRecord->album)-1);
getText(hwnd,EF_COMMENTS,buffer,sizeof(buffer));
strncpy(posRecord->comment, buffer, sizeof(posRecord->comment)-1);
getText(hwnd,EF_GENRE,buffer,sizeof(buffer));
strncpy(posRecord->genre, buffer, sizeof(posRecord->genre)-1);
getFallbackFF(buffer2, sizeof(buffer2));
}
formatFilename(buffer,sizeof(buffer),buffer2,posRecord,hwnd);
posRecord->record.pszIcon = posRecord->record.pszText =
posRecord->record.pszName = posRecord->record.pszTree =
(char*) malloc(strlen(buffer)+1);
strcpy(posRecord->record.pszIcon,makeValidLFN(buffer));
/* "next!" */
posRecord = (CDTRACKRECORD *) posRecord->record.preccNextRecord;
}
recordInfo.cb = sizeof(recordInfo);
recordInfo.pRecordOrder = (RECORDCORE *) CMA_END;
recordInfo.pRecordParent = NULL;
recordInfo.fInvalidateRecord = TRUE;
recordInfo.zOrder = CMA_TOP;
recordInfo.cRecordsInsert = cdDrive->getCount();
insertRecords(hwnd, CT_TRACK, (RECORDCORE *) firstRecord, &recordInfo);
delete cdDrive; cdDrive = NULL;
delete cddbSocket; cddbSocket = NULL;
}
int midParseInt(int identifier,int fd, char *data, int len)
{
int recvlen;
int cmd = 0;
int actdata = 0;
//char logoname[15] = "logo.png";
int ret = 0;
int web_ret = SERVER_RET_OK;
int need_send = 0;
char senddata[1024] = {0};
int totallen = 0;
recvlen = recv(fd, data, len, 0);
int out = 0;
// if(recvlen < 0) {
// return -1;
// }
if(recvlen < 0 || len != sizeof(cmd) + sizeof(int)) {
web_ret = SERVER_RET_INVAID_PARM_LEN;
need_send = 1;
goto EXIT;
}
memcpy(&cmd, data, sizeof(int));
memcpy(&actdata, data + sizeof(int), len - sizeof(int));
PRINTF("cmd = 0x%04x\n", cmd);
switch(cmd) {
case MSG_GETINPUTTYPE:
PRINTF("cmd = 0x%04x is MSG_GETINPUTTYPE.\n", cmd);
ret = getinputType(actdata, &out);
need_send = 1;
break;
case MSG_SETINPUTTYPE:
PRINTF("cmd = 0x%04x is MSG_SETINPUTTYPE.\n", cmd);
ret = setInputType(actdata, &out);
need_send = 1;
break;
//case MSG_STOP_MULT:
// stopMultParse(fd, cmd, &actdata);
// break;
case MSG_GETCPULOAD:
PRINTF("cmd = 0x%04x is MSG_GETCPULOAD.\n", cmd);
ret = getcpuload(actdata, &out);
need_send = 1;
break;
case MSG_RESTORESET:
PRINTF("cmd = 0x%04x is MSG_RESTORESET.\n", cmd);
ret = restoresetparse(actdata, &out);
need_send = 1;
break;
case MSG_GET_CTRL_PROTO:
PRINTF("cmd = 0x%04x is MSG_GET_CTRL_PROTO.\n", cmd);
need_send = 1;
getCtrlProto(actdata, &out);
break;
case MSG_SET_CTRL_PROTO:
PRINTF("cmd = 0x%04x is MSG_SET_CTRL_PROTO.\n", cmd);
need_send = 1;
setCtrlProto(actdata, &out);
break;
/*
case MSG_SAVEPARAM:
saveParams(fd, cmd, &actdata);
break;
*/
#if 0
case MSG_GETDHCPFLAG:
PRINTF("cmd = 0x%04x is MSG_GETDHCPFLAG.\n", cmd);
need_send = 1;
PRINTF("MSG_GETDHCPFLAG actdata = %d\n", actdata);
webgetDHCPFlag(actdata, &out);
break;
case MSG_SETDHCPFLAG:
PRINTF("cmd = 0x%04x is MSG_SETDHCPFLAG.\n", cmd);
need_send = 1;
websetDHCPFlag(actdata, &out);
break;
#endif
case MSG_SETCOLORSPACE:
PRINTF("cmd = 0x%04x is MSG_SETCOLORSPACE.\n", cmd);
need_send = 1;
ret = setColorSpace(actdata, &out);
break;
case MSG_GETCOLORSPACE:
PRINTF("cmd = 0x%04x is MSG_GETCOLORSPACE.\n", cmd);
getColorSpace(&out);
need_send = 1;
break;
//case MSG_GETHDCPVAL:
// getHDCPValue(fd, cmd, &actdata);
// break;
case MSG_REBOOTSYS:
PRINTF("cmd = 0x%04x is MSG_REBOOTSYS.\n", cmd);
need_send = 1;
rebootSys(actdata, &out);
break;
case MSG_GETHDCPVALUE:
PRINTF("cmd = 0x%04x is MSG_GETHDCPVALUE.\n", cmd);
need_send = 1;
getHDCPValue(actdata, &out);
break;
case MSG_LOCK_RESOLUTION:
PRINTF("cmd = 0x%04x is MSG_LOCK_RESOLUTION.\n", cmd);
ret = DoLockResolution(actdata, &out);
need_send = 1;
break;
case MSG_GETOUTPUTRESOLUTION:
PRINTF("cmd = 0x%04x is MSG_GETOUTPUTRESOLUTION.\n", cmd);
ret = webgetOutputResolution(actdata, &out);
need_send = 1;
break;
case MSG_RESIZE_MODE:
PRINTF("cmd = 0x%04x is MSG_RESIZE_MODE.\n", cmd);
// setResizeMode(fd, cmd, &actdata);
ret = setResizeMode(actdata, &out);
need_send = 1;
break;
case MSG_GETRESIZEMODE:
PRINTF("cmd = 0x%04x is MSG_GETRESIZEMODE.\n", cmd);
//getResizeMode(fd, cmd, &actdata);
ret = getResizeMode(actdata, &out);
need_send = 1;
break;
case MSG_GETENCODELV:
PRINTF("cmd = 0x%04x is MSG_GETENCODELV.\n", cmd);
ret = getEncodelevel(actdata, &out);
need_send = 1;
break;
case MSG_SETENCODELV:
PRINTF("cmd = 0x%04x is MSG_SETENCODELV.\n", cmd);
ret = setEncodelevel(actdata, &out);
need_send = 1;
break;
case MSG_GETSCENE:
PRINTF("cmd = 0x%04x is MSG_GETSCENE.\n", cmd);
need_send = 1;
getSceneconfig(actdata, &out);
break;
case MSG_SETSCENE:
PRINTF("cmd = 0x%04x is MSG_SETSCENE.\n", cmd);
need_send = 1;
ret = setSceneconfig(actdata, &out);
break;
case MSG_GETFRAMERATE:
PRINTF("cmd = 0x%04x is MSG_GETFRAMERATE.\n", cmd);
need_send = 1;
getFrameRate(actdata, &out);
break;
case MSG_SETFRAMERATE:
PRINTF("cmd = 0x%04x is MSG_SETFRAMERATE.\n", cmd);
need_send = 1;
ret = setFrameRate(actdata, &out);
break;
case MSG_GETIFRAMEINTERVAL:
PRINTF("cmd = 0x%04x is MSG_GETIFRAMEINTERVAL.\n", cmd);
need_send = 1;
getIFrameInterval(actdata, &out);
break;
//case MSG_SETIFRAMEINTERVAL:
// PRINTF("cmd = 0x%04x is MSG_SETIFRAMEINTERVAL.\n", cmd);
// need_send = 1;
// ret = setIFrameInterval(actdata, &out);
// break;
case MSG_GETBITRATE:
PRINTF("cmd = 0x%04x is MSG_GETBITRATE.\n", cmd);
need_send = 1;
getBitRate(actdata, &out);
break;
case MSG_SETBITRATE:
PRINTF("cmd = 0x%04x is MSG_SETBITRATE.\n", cmd);
need_send = 1;
ret = setBitRate(actdata, &out);
break;
case MSG_SETMUTE:
PRINTF("cmd = 0x%04x is MSG_SETMUTE.\n", cmd);
need_send = 1;
ret = webSetMute(actdata, &out);
break;
case MSG_GETMUTE:
PRINTF("cmd = 0x%04x is MSG_GETMUTE.\n", cmd);
webGetMute(actdata, &out);
need_send = 1;
break;
//stream_ouput
case MSG_RTSP_GET_USED:
case MSG_RTSP_DEL_SERVER:
case MSG_MULT_GET_NUM:
case MSG_MULT_GET_TS_RATE:
case MSG_MULT_GET_RTP_RATE:
case MSG_MULT_GET_RTPTS_RATE:
app_web_stream_output_process_int(cmd, actdata, &out);
need_send = 1;
break;
//case MSG_GETSHOWTEXTLOGO:
// PRINTF("cmd = 0x%04x is MSG_GETSHOWTEXTLOGO.\n", cmd);
// webgetShowLogoTextFlag(actdata, &out);
// need_send = 1;
// break;
// case MSG_SETSHOWTEXTLOGO:
// PRINTF("cmd = 0x%04x is MSG_SETSHOWTEXTLOGO.\n", cmd);
// ret = websetShowLogoTextFlag(actdata, &out);
// need_send = 1;
// break;
// case MSG_GET_SHOWTEXT_FLAG:
// out = app_get_textshow_flag();
// need_send = 1;
// break;
// case MSG_SET_SHOWTEXT_FLAG:
// out = app_set_textshow_flag(actdata);
// need_send = 1;
// break;
// case MSG_GET_SHOWLOGO_FLAG:
// out = app_get_logoshow_flag();
// need_send = 1;
// break;
// case MSG_SET_SHOWLOGO_FLAG:
// out = app_set_logoshow_flag(actdata);
// need_send = 1;
// break;
default:
PRINTF("unkonwn cmd = %04x\n", cmd);
need_send = 1;
web_ret = SERVER_RET_UNKOWN_CMD;
break;
// case
}
if(ret < 0) {
web_ret = SERVER_RET_INVAID_PARM_VALUE;
}
EXIT:
if(need_send == 1) {
totallen = MSGINFOHEAD + sizeof(cmd) + sizeof(web_ret) + sizeof(out);
msgPacket(identifier,senddata, INT_TYPE, totallen, cmd, web_ret);
memcpy(senddata + (totallen - sizeof(out)), &out, sizeof(out));
PRINTF("the cmd =%04x,the value=%d,the ret=%04x\n", cmd, out, web_ret);
send(fd, senddata, totallen, 0);
}
return 0;
}
/*------------------------------------------------------------------------------
* Log in to the ShoutCast server using the icy login scheme
*----------------------------------------------------------------------------*/
bool
ShoutCast :: sendLogin ( void ) throw ( Exception )
{
Sink * sink = getSink();
Source * source = getSocket();
const char * str;
char resp[STRBUF_SIZE];
unsigned int len;
if ( !source->isOpen() ) {
return false;
}
if ( !sink->isOpen() ) {
return false;
}
/* first line is the password in itself */
str = getPassword();
sink->write( str, strlen( str));
str = "\n";
sink->write( str, strlen( str));
sink->flush();
/* read the anticipated response: "OK" */
len = source->read( resp, STRBUF_SIZE);
reportEvent(8, "server response length: ", len);
reportEvent(8, "server response: ", resp);
if ( len < 2 || resp[0] != 'O' || resp[1] != 'K' ) {
return false;
}
/* suck anything that the other side has to say */
while ( source->canRead( 0, 0) &&
(len = source->read( resp, STRBUF_SIZE)) ) {
;
}
/* send the icy headers */
if ( getName() ) {
str = "icy-name:";
sink->write( str, strlen( str));
str = getName();
sink->write( str, strlen( str));
}
if ( getGenre() ) {
str = "\nicy-genre:";
sink->write( str, strlen( str));
str = getGenre();
sink->write( str, strlen( str));
}
str = "\nicy-pub:";
sink->write( str, strlen( str));
str = getIsPublic() ? "1" : "0";
sink->write( str, strlen( str));
str = "\nicy-br:";
sink->write( str, strlen( str));
if ( log10(getBitRate()) >= (STRBUF_SIZE-2) ) {
throw Exception( __FILE__, __LINE__,
"bitrate does not fit string buffer", getBitRate());
}
sprintf( resp, "%d", getBitRate());
sink->write( resp, strlen( resp));
if ( getUrl() ) {
str = "\nicy-url:";
sink->write( str, strlen( str));
str = getUrl();
sink->write( str, strlen( str));
}
if ( getIrc() ) {
str = "\nicy-irc:";
sink->write( str, strlen( str));
str = getIrc();
sink->write( str, strlen( str));
}
if ( getIcq() ) {
str = "\nicy-icq:";
sink->write( str, strlen( str));
str = getIcq();
sink->write( str, strlen( str));
}
if ( getAim() ) {
str = "\nicy-aim:";
sink->write( str, strlen( str));
str = getAim();
sink->write( str, strlen( str));
}
str = "\n\n";
sink->write( str, strlen( str));
sink->flush();
/* suck anything that the other side has to say */
len = source->read( resp, STRBUF_SIZE);
reportEvent(8, "server response length: ", len);
reportEvent(8, "server response: ", resp);
while ( source->canRead( 0, 0) &&
(len = source->read( resp, STRBUF_SIZE)) ) {
;
}
return true;
}
/*------------------------------------------------------------------------------
* Log in to the ShoutCast server using the icy login scheme
*----------------------------------------------------------------------------*/
bool
ShoutCast :: sendLogin ( void ) throw ( Exception )
{
Sink * sink = getSink();
Source * source = getSocket();
const char * str;
char resp[STRBUF_SIZE];
unsigned int len;
bool needsMountPoint = false;
const char * mountPoint = getMountPoint();
if ( !source->isOpen() ) {
return false;
}
if ( !sink->isOpen() ) {
return false;
}
// We will add SOURCE only if really needed: if the mountPoint is not null
// and is different of "/". This is to keep maximum compatibility with
// NullSoft Shoutcast server.
if (mountPoint != 0L
&& strlen(mountPoint) > 0 && 0 != strcmp("/", mountPoint)) {
needsMountPoint = true;
}
std::ostringstream os;
if (needsMountPoint) {
os << "SOURCE ";
}
/* first line is the password in itself */
os << getPassword();
os << "\n";
// send the mount point
if (needsMountPoint) {
os << " ";
if (strncmp("/", mountPoint, 1) != 0) {
os << "/";
}
os << mountPoint;
os << "\n";
}
str = os.str().c_str();
// Ok, now we send login which will be different of classical Shoutcast
// if mountPoint is not null and is different from "/" ...
sink->write( str, strlen( str));
sink->flush();
/* read the anticipated response: "OK" */
len = source->read( resp, STRBUF_SIZE);
reportEvent(8, "server response length: ", len);
reportEvent(8, "server response: ", resp);
if ( len < 2 || resp[0] != 'O' || resp[1] != 'K' ) {
return false;
}
/* suck anything that the other side has to say */
while ( source->canRead( 0, 0) &&
(len = source->read( resp, STRBUF_SIZE)) ) {
;
}
/* send the icy headers */
if ( getName() ) {
str = "icy-name:";
sink->write( str, strlen( str));
str = getName();
sink->write( str, strlen( str));
}
if ( getUrl() ) {
str = "\nicy-url:";
sink->write( str, strlen( str));
str = getUrl();
sink->write( str, strlen( str));
}
if ( getGenre() ) {
str = "\nicy-genre:";
sink->write( str, strlen( str));
str = getGenre();
sink->write( str, strlen( str));
}
if ( getIrc() ) {
str = "\nicy-irc:";
sink->write( str, strlen( str));
str = getIrc();
sink->write( str, strlen( str));
}
if ( getAim() ) {
str = "\nicy-aim:";
sink->write( str, strlen( str));
str = getAim();
sink->write( str, strlen( str));
}
if ( getIcq() ) {
str = "\nicy-icq:";
sink->write( str, strlen( str));
str = getIcq();
sink->write( str, strlen( str));
}
str = "\nicy-br:";
sink->write( str, strlen( str));
if ( log10(getBitRate()) >= (STRBUF_SIZE-2) ) {
throw Exception( __FILE__, __LINE__,
"bitrate does not fit string buffer", getBitRate());
}
sprintf( resp, "%d", getBitRate());
sink->write( resp, strlen( resp));
str = "\nicy-pub:";
sink->write( str, strlen( str));
str = getIsPublic() ? "1" : "0";
sink->write( str, strlen( str));
str = "\n\n";
sink->write( str, strlen( str));
sink->flush();
return true;
}
