steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/DSP/dsp_sc/sc2srclib/Include/shoutcast_output.h

817 lines
22 KiB
C++
Raw Blame History

#ifndef __SHOUTCAST_OUTPUT_H__
#define __SHOUTCAST_OUTPUT_H__
#include <time.h>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <list>
#include <fstream>
#include "c_serial_jobmanager.h"
#include "../Components/wac_network/wac_network_connection_api.h"
#include <WinSock2.h>
#include "../Encoders/c_encoder.h"
#include "../Encoders/c_encoder_mp3dll.h"
#include "../lame/include/lame.h"
#include "../lame/libmp3lame/lame_global_flags.h"
#include "../uvAuth21/uvAuth21.h"
#define UV_SYNC_BYTE 0x5A
#define UV_RESERVED 0x00
#define UV_END 0x00
#define UV_END_LEN 1
#define UV_HEADER_LEN 6
#define UV_META_LEN 6
#define UV_FRAME_LEN 16384
#define UV_MAX_DATA_LEN (UV_FRAME_LEN - UV_HEADER_LEN - UV_END_LEN)
#define UV_MAX_META_LEN (UV_FRAME_LEN - UV_HEADER_LEN - UV_META_LEN - UV_END_LEN)
#define UV_MAX_META_FRAGMENTS 32
#define UV_MAX_TOTAL_META_LEN (UV_MAX_META_LEN * UV_MAX_META_FRAGMENTS)
typedef struct {
char* name;
bool parent;
bool children;
} SCgenres;
static SCgenres genres[] = {{"Alternative", true, true},
{"Adult Alternative", false},
{"Britpop", false},
{"Classic Alternative", false},
{"College", false},
{"Dancepunk", false},
{"Dream Pop", false},
{"Emo", false},
{"Goth", false},
{"Grunge", false},
{"Hardcore", false},
{"Indie Pop", false},
{"Indie Rock", false},
{"Industrial", false},
{"LoFi", false},
{"Modern Rock", false},
{"New Wave", false},
{"Noise Pop", false},
{"Post Punk", false},
{"Power Pop", false},
{"Punk", false},
{"Ska", false},
{"Xtreme", false},
{"Blues", true, true},
{"Acoustic Blues", false},
{"Cajun and Zydeco", false},
{"Chicago Blues", false},
{"Contemporary Blues", false},
{"Country Blues", false},
{"Delta Blues", false},
{"Electric Blues", false},
{"Classical", true, true},
{"Baroque", false},
{"Chamber", false},
{"Choral", false},
{"Classical Period", false},
{"Early Classical", false},
{"Impressionist", false},
{"Modern", false},
{"Opera", false},
{"Piano", false},
{"Romantic", false},
{"Symphony", false},
{"Country", true, true},
{"Alt Country", false},
{"Americana", false},
{"Bluegrass", false},
{"Classic Country", false},
{"Contemporary Bluegrass", false},
{"Contemporary Country", false},
{"Honky Tonk", false},
{"Hot Country Hits", false},
{"Western", false},
{"Decades", true, true},
{"30s", false},
{"40s", false},
{"50s", false},
{"60s", false},
{"70s", false},
{"80s", false},
{"90s", false},
{"00s", false},
{"Easy Listening", true, true},
{"Exotica", false},
{"Light Rock", false},
{"Lounge", false},
{"Orchestral Pop", false},
{"Polka", false},
{"Space Age Pop", false},
{"Electronic", true, true},
{"Acid House", false},
{"Ambient", false},
{"Big Beat", false},
{"Breakbeat", false},
{"Dance", false},
{"Demo", false},
{"Disco", false},
{"Downtempo", false},
{"Drum and Bass", false},
{"Dubstep", false},
{"Electro", false},
{"Garage", false},
{"Hard House", false},
{"House", false},
{"IDM", false},
{"Jungle", false},
{"Progressive", false},
{"Techno", false},
{"Trance", false},
{"Tribal", false},
{"Trip Hop", false},
{"Folk", true, true},
{"Alternative Folk", false},
{"Contemporary Folk", false},
{"Folk Rock", false},
{"New Acoustic", false},
{"Old Time", false},
{"Traditional Folk", false},
{"World Folk", false},
{"Inspirational", true, true},
{"Christian", false},
{"Christian Metal", false},
{"Christian Rap", false},
{"Christian Rock", false},
{"Classic Christian", false},
{"Contemporary Gospel", false},
{"Gospel", false},
{"Praise and Worship", false},
{"Sermons and Services", false},
{"Southern Gospel", false},
{"Traditional Gospel", false},
{"International", true, true},
{"African", false},
{"Afrikaans", false},
{"Arabic", false},
{"Asian", false},
{"Bollywood", false},
{"Brazilian", false},
{"Caribbean", false},
{"Celtic", false},
{"Creole", false},
{"European", false},
{"Filipino", false},
{"French", false},
{"German", false},
{"Greek", false},
{"Hawaiian and Pacific", false},
{"Hebrew", false},
{"Hindi", false},
{"Indian", false},
{"Islamic", false},
{"Japanese", false},
{"Klezmer", false},
{"Korean", false},
{"Mediterranean", false},
{"Middle Eastern", false},
{"North American", false},
{"Russian", false},
{"Soca", false},
{"South American", false},
{"Tamil", false},
{"Turkish", false},
{"Worldbeat", false},
{"Zouk", false},
{"Jazz", true, true},
{"Acid Jazz", false},
{"Avant Garde", false},
{"Big Band", false},
{"Bop", false},
{"Classic Jazz", false},
{"Cool Jazz", false},
{"Fusion", false},
{"Hard Bop", false},
{"Latin Jazz", false},
{"Smooth Jazz", false},
{"Swing", false},
{"Vocal Jazz", false},
{"World Fusion", false},
{"Latin", true, true},
{"Bachata", false},
{"Banda", false},
{"Bossa Nova", false},
{"Cumbia", false},
{"Flamenco", false},
{"Latin Dance", false},
{"Latin Pop", false},
{"Latin Rap and Hip Hop", false},
{"Latin Rock", false},
{"Mariachi", false},
{"Merengue", false},
{"Ranchera", false},
{"Reggaeton", false},
{"Regional Mexican", false},
{"Salsa", false},
{"Samba", false},
{"Tango", false},
{"Tejano", false},
{"Tropicalia", false},
{"Metal", true, true},
{"Black Metal", false},
{"Classic Metal", false},
{"Death Metal", false},
{"Extreme Metal", false},
{"Grindcore", false},
{"Hair Metal", false},
{"Heavy Metal", false},
{"Metalcore", false},
{"Power Metal", false},
{"Progressive Metal", false},
{"Rap Metal", false},
{"Thrash Metal", false},
{"Misc", true, false},
{"New Age", true, true},
{"Environmental", false},
{"Ethnic Fusion", false},
{"Healing", false},
{"Meditation", false},
{"Spiritual", false},
{"Pop", true, true},
{"Adult Contemporary", false},
{"Barbershop", false},
{"Bubblegum Pop", false},
{"Dance Pop", false},
{"Idols", false},
{"JPOP", false},
{"KPOP", false},
{"Oldies", false},
{"Soft Rock", false},
{"Teen Pop", false},
{"Top 40", false},
{"World Pop", false},
{"Public Radio", true, true},
{"College", false},
{"News", false},
{"Sports", false},
{"Talk", false},
{"Weather", false},
{"R&B and Urban", true, false},
{"Classic R&B", false},
{"Contemporary R&B", false},
{"Doo Wop", false},
{"Funk", false},
{"Motown", false},
{"Neo Soul", false},
{"Quiet Storm", false},
{"Soul", false},
{"Urban Contemporary", false},
{"Rap", true, true},
{"Alternative Rap", false},
{"Dirty South", false},
{"East Coast Rap", false},
{"Freestyle", false},
{"Gangsta Rap", false},
{"Hip Hop", false},
{"Mixtapes", false},
{"Old School", false},
{"Turntablism", false},
{"Underground Hip Hop", false},
{"West Coast Rap", false},
{"Reggae", true, true},
{"Contemporary Reggae", false},
{"Dancehall", false},
{"Dub", false},
{"Pop Reggae", false},
{"Ragga", false},
{"Reggae Roots", false},
{"Rock Steady", false},
{"Rock", true, true},
{"Adult Album Alternative", false},
{"British Invasion", false},
{"Celtic Rock", false},
{"Classic Rock", false},
{"Garage Rock", false},
{"Glam", false},
{"Hard Rock", false},
{"Jam Bands", false},
{"JROCK", false},
{"Piano Rock", false},
{"Prog Rock", false},
{"Psychedelic", false},
{"Rock & Roll", false},
{"Rockabilly", false},
{"Singer and Songwriter", false},
{"Surf", false},
{"Seasonal and Holiday", true, true},
{"Anniversary", false},
{"Birthday", false},
{"Christmas", false},
{"Halloween", false},
{"Hanukkah", false},
{"Honeymoon", false},
{"Kwanzaa", false},
{"Valentine", false},
{"Wedding", false},
{"Winter", false},
{"Soundtracks", true, true},
{"Anime", false},
{"Kids", false},
{"Original Score", false},
{"Showtunes", false},
{"Video Game Music", false},
{"Talk", true, true},
{"BlogTalk", false},
{"Comedy", false},
{"Community", false},
{"Educational", false},
{"Government", false},
{"News", false},
{"Old Time Radio", false},
{"Other Talk", false},
{"Political", false},
{"Scanner", false},
{"Spoken Word", false},
{"Sports", false},
{"Technology", false},
{"Themes", true, true},
{"Adult", false},
{"Best Of", false},
{"Chill", false},
{"Eclectic", false},
{"Experimental", false},
{"Female", false},
{"Heartache", false},
{"Instrumental", false},
{"LGBT", false},
{"Love and Romance", false},
{"Party Mix", false},
{"Patriotic", false},
{"Rainy Day Mix", false},
{"Reality", false},
{"Sexy", false},
{"Shuffle", false},
{"Travel Mix", false},
{"Tribute", false},
{"Trippy", false},
{"Work Mix", false}
};
// pulled from nmrCommon\intTypes.h
typedef unsigned char __uint8;
typedef unsigned short __uint16;
typedef unsigned int __uint32;
typedef unsigned long long __uint64;
#pragma pack(push,1)
// this structure should be 16384 bytes in total size
// and is defined in full size so that we know its ok
struct uv2xHdr
{ // uvox2 message
__uint8 sync;
__uint8 qos;
__uint16 msgType;
__uint16 msgLen;
__uint8 m_data[UV_MAX_DATA_LEN];
__uint8 end;
};
struct uv2xMetadataHdr
{ /* uvox 2 metadata header */
__uint8 sync;
__uint8 qos;
__uint16 msgType;
__uint16 msgLen;
__uint16 id; /* ID (cookie) identifying a metadata package */
__uint16 span; /* Span of messages in the metadata package being assembled */
__uint16 index; /* Index of the message in the metadata package being assembled */
__uint8 m_data[UV_MAX_META_LEN];
__uint8 end;
};
#pragma pack(pop)
#define MSG_AUTH 0x1001
#define MSG_BROADCAST_SETUP 0x1002
#define MSG_NEGOTIATE_BUFFER_SIZE 0x1003
#define MSG_STANDBY 0x1004
#define MSG_TERMINATE 0x1005
#define MSG_FLUSH_CACHED_METADATA 0x1006
#define MSG_LISTENER_AUTHENTICATION 0x1007
#define MSG_MAX_PAYLOAD_SIZE 0x1008
#define MSG_CIPHER 0x1009
#define MSG_MIME_TYPE 0x1040
#define MSG_FILE_TRANSFER_BEGIN 0x1050
#define MSG_FILE_TRANSFER_DATA 0x1051
#define MSG_BROADCAST_INTERRUPTION 0x2001
#define MSG_BROADCAST_TERMINATE 0x2002
#define MSG_ICYNAME 0x1100
#define MSG_ICYGENRE 0x1101
#define MSG_ICYURL 0x1102
#define MSG_ICYPUB 0x1103
#define MSG_METADATA_CONTENTINFO 0x3000
#define MSG_METADATA_URL 0x3001
#define MSG_METADATA_XML 0x3901
#define MSG_METADATA_XML_NEW 0x3902
// only id the start of the album art type as it's variable
#define MSG_METADATA_ALBUMART 0x4000
#define MSG_METADATA_STATION_ART 0x0000
#define MSG_METADATA_PLAYING_ART 0x0100
/*
0x4 0x0xx Station logo
0x4 0x1xx Album art
00 = image/jpeg
01 = image/png
02 = image/bmp
03 = image/gif
*/
#define MSG_METADATA_TIMEREMAINING 0x5001
#define MP3_DATA 0x7000
#define VLB_DATA 0x8000
#define AAC_LC_DATA 0x8001
#define AACP_DATA 0x8003
#define OGG_DATA 0x8004
struct T_OUTPUT_CONFIG {
char Name[32];
wchar_t DisplayName[32];
char UserID[256];
char Address[1024];
u_short Port;
char StationID[12];
char Password[256]; // 4 - 8 for 1.8.2
char cipherkey[64]; // sc2 cipherkey
int AutoRecon;
int ReconTime;
char Description[1024];
char ServerURL[2048];
char Genre[256];
char ICQ[128];
char AIM[1024];
char IRC[1024];
int Public;
int doTitleUpdate;
int protocol;
int protocol_retry;
char Now[1024];
char Next[1024];
};
#define DEFAULT_ENCODER (C_ENCODER *)(-1)
#define OM_ENCODE 1
#define OM_OUTPUT 2
#define OM_OTHER 4
#define OM_ALL (OM_ENCODE | OM_OUTPUT | OM_OTHER)
enum OUTPUTTYPE {
OUTTYPE_SOURCE,
OUTTYPE_TITLE,
};
typedef unsigned long ARGB32;
struct T_OUTPUT_TITLE {
wchar_t *Title;
wchar_t *Song;
wchar_t *Album;
wchar_t *Artist;
wchar_t *Genre;
wchar_t *Comment;
wchar_t *Year;
std::vector<std::wstring> NextList;
void *APIC[2];
int APICLength[2];
int APICType[2];
T_OUTPUT_TITLE() : Title(0), Song(0), Album(0), Artist(0), Genre(0), Comment(0), Year(0)
{
memset(APIC, 0, sizeof(void *) * 2);
memset(APICLength, 0, sizeof(int) * 2);
memset(APICType, 0, sizeof(int) * 2);
}
~T_OUTPUT_TITLE()
{
if (Title)
{
free(Title);
Title = 0;
}
if (Song)
{
free(Song);
Song = 0;
}
if (Album)
{
free(Album);
Album = 0;
}
if (Artist)
{
free(Artist);
Artist = 0;
}
if (Genre)
{
free(Genre);
Genre = 0;
}
if (Comment)
{
free(Comment);
Comment = 0;
}
if (Year)
{
free(Year);
Year = 0;
}
}
};
struct T_OUTPUT_INFO {
unsigned int BytesSent; // how many bytes of content we've sent
clock_t ConnectionTime; // time a socket connection occurred
int Version; // server version
int Caps; // server capabilities
int Reconnect; // flag for the reconnection algorithm
int ReconnectTime; // value used in conjunction with the reconnection algorithm
int Succeeded; // had at least one successful connection (for reconnection alg.) -1 = password failure
int last_state; // using this as a means to allow for closing on errors but able to show a better message
int Switching; // if we're doing an automatic protocol version change (from v2 to v1)
char *ErrorMsg;
time_t ConnectedAt;
int meta_cached;
int art_cached[2];
unsigned short art_index[2];
unsigned short art_cached_span[2];
int art_cached_length[2];
// metadata information about the stream, etc
wchar_t *Title;
std::vector<std::wstring> NextList;
wchar_t *Song;
wchar_t *Album;
wchar_t *Artist;
wchar_t *Genre;
wchar_t *Comment;
wchar_t *Year;
void *APIC[2];
int APICLength[2];
int APICType[2];
T_OUTPUT_INFO() : BytesSent(0), ConnectionTime(0), Version(0),
Caps(0), Reconnect(0), ReconnectTime(0),
Succeeded(0), last_state(0), Switching(0),
ErrorMsg(0), ConnectedAt(0), meta_cached(0),
Title(0), Song(0), Album(0), Artist(0),
Genre(0), Comment(0), Year(0)
{
memset(art_cached, 0, sizeof(int) * 2);
memset(art_index, 0, sizeof(unsigned short) * 2);
memset(art_cached_span, 0, sizeof(unsigned short) * 2);
memset(art_cached_length, 0, sizeof(int) * 2);
memset(APIC, 0, sizeof(void *) * 2);
memset(APICLength, 0, sizeof(int) * 2);
memset(APICType, 0, sizeof(int) * 2);
}
~T_OUTPUT_INFO()
{
if (Title)
{
free(Title);
Title = 0;
}
if (Song)
{
free(Song);
Song = 0;
}
if (Album)
{
free(Album);
Album = 0;
}
if (Artist)
{
free(Artist);
Artist = 0;
}
if (Genre)
{
free(Genre);
Genre = 0;
}
if (Comment)
{
free(Comment);
Comment = 0;
}
if (Year)
{
free(Year);
Year = 0;
}
if (Succeeded == -2 && ErrorMsg) {
free(ErrorMsg);
ErrorMsg = 0;
}
}
};
struct T_OUTPUT {
int Connection; // using this for the title update callback so the correct instance is updated
void (*TitleCallback)(const int Connection, const int Mode);
api_connection *Output;
enum OUTPUTTYPE Type;
int Bitrate; // this shouldn't be here, but it's the only way we can tell the shoutcast server the bitrate
char *ContentType; // neither should this
int SlowClose; // set to 1 to wait until all data is sent before closing the connection
T_OUTPUT_CONFIG *Config;
T_OUTPUT_INFO Info;
T_OUTPUT() : Connection(0), TitleCallback(0), Output(0), Type(OUTTYPE_SOURCE), Bitrate(0), ContentType(0), SlowClose(0), Config(0) {}
};
enum OUTPUTSTATE {
OUT_ERROR, // not a true state, but is returned when GetState() is called with an invalid connection handle
OUT_DISCONNECTED,
OUT_CONNECT,
OUT_REQUEST_CIPHER,
OUT_RECV_CIPHER,
OUT_SENDAUTH,
OUT_RECVAUTHRESPONSE,
OUT_SEND_MIME,
OUT_RECV_MIME,
OUT_SEND_BITRATE,
OUT_RECV_BITRATE,
OUT_SEND_BUFSIZE,
OUT_RECV_BUFSIZE,
OUT_SEND_MAX,
OUT_RECV_MAX,
OUT_SENDYP,
OUT_SEND_INITFLUSH,
OUT_RECV_INITFLUSH,
OUT_SEND_INITSTANDBY,
OUT_RECV_INITSTANDBY,
/*OUT_SEND_INTRO,
OUT_RECV_INTRO,
OUT_SEND_BACKUP,
OUT_RECV_BACKUP,*/
OUT_SENDCONTENT,
OUT_DISCONNECT,
OUT_RECONNECT,
OUT_TITLESENDUPDATE,
OUT_FAIL_CIPHER,
OUT_SEND_METADATA,
OUT_SEND_ARTWORK,
};
static void *mutex;
class SHOUTCAST_OUTPUT {
private:
C_ENCODER *Encoder;
int IOwnEncoder;
C_SERIAL_JOBMANAGER<T_OUTPUT> OutputManager;
T_OUTPUT_TITLE metadata;
protected:
static int Output_Disconnected(int state, int last_state, T_OUTPUT *userData);
static int Output_Connect(int state, int last_state, T_OUTPUT *userData);
static int Output_Request_Cipher(int state, int last_state, T_OUTPUT *userData);
static int Output_Receive_Cipher(int state, int last_state, T_OUTPUT *userData);
static int Output_SendAuth(int state, int last_state, T_OUTPUT *userData);
static int Output_RecvAuthResponse(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Mime(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_Mime(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Bitrate(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_Bitrate(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Buf_Size(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_Buf_Size(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Max_Size(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_Max_Size(int state, int last_state, T_OUTPUT *userData);
static int Output_DUMMY(int state, int last_state, T_OUTPUT *userData);
static int Output_SendYP(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_InitFlush(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_InitFlush(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_InitStandby(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_InitStandby(int state, int last_state, T_OUTPUT *userData);
/*static int Output_Send_Intro(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_Intro(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Backup(int state, int last_state, T_OUTPUT *userData);
static int Output_Recv_Backup(int state, int last_state, T_OUTPUT *userData);*/
static int Output_SendContent(int state, int last_state, T_OUTPUT *userData);
static int Output_Disconnect(int state, int last_state, T_OUTPUT *userData);
static int Output_Reconnect(int state, int last_state, T_OUTPUT *userData);
static int Output_Title_SendUpdate(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Metadata(int state, int last_state, T_OUTPUT *userData);
static int Output_Send_Artwork(int state, int last_state, T_OUTPUT *userData);
// uvox21
static void createUvoxFrame(int length, char *payload_in, int type, T_OUTPUT *userData);
static int createUvoxMetaFrame(int length, char *payload_in, int type,
T_OUTPUT *userData, unsigned short id, unsigned short span = 1);
static int parseUvoxFrame(char *payload_in, char *payload_out);
static int checkUvoxFrameForError(char *pload_out, int state, T_OUTPUT *userData);
void (*lame_init)(void);
void (*lame_init_params)(lame_global_flags *);
int (*lame_encode_buffer_interleaved)(lame_global_flags *, short int pcm[], int num_samples, char *mp3buffer, int mp3buffer_size);
int (*lame_encode_flush)(lame_global_flags *, char *mp3buffer, int size);
HINSTANCE libinst;
public:
SHOUTCAST_OUTPUT();
void SetLame(void *init, void *params, void *encode, void *finish);
~SHOUTCAST_OUTPUT();
int Run(int mode = 0, void *Input = NULL, int InputSize = 0, int SaveEncoder = -1);
int AddOutput(int Connection, T_OUTPUT_CONFIG *Config, void (*TitleCallback)(const int Connection, const int Mode)=0);
void UpdateOutput(int Connection);
void RemoveOutput(int Connection);
int ConnectOutput(int Connection);
int DisconnectOutput(int Connection, int withReconnect = 0, int reconnectTime = -1); // withReconnect of -1 will use the output config's setting
void SetEncoder(C_ENCODER *encoder, int takeOwnership = 0);
// we will attempt to cache the title information to save on duplication and
// also to make it easier for the title to be re-sent on server disconnect
void UpdateTitleCache(wchar_t *Title, std::vector<std::wstring> NextList, wchar_t *Song,
wchar_t *Album, wchar_t *Artist, wchar_t *Genre, wchar_t *Comment,
wchar_t* Year, int Connection, bool sendNext);
void UpdateTitle(wchar_t *Title, std::vector<std::wstring> NextList,
int Connection, bool sendNext, bool UseCache = true);
void UpdateArtwork(int Connection);
void UpdateAlbumArtCache(void* APIC, int APIClength, int APICType, int Connection);
int UpdateAlbumArt(int Connection);
enum OUTPUTSTATE GetState(int Connection);
T_OUTPUT_CONFIG *operator[](int Connection);
T_OUTPUT_CONFIG *GetOutput(int Connection);
C_ENCODER *GetEncoder();
T_OUTPUT_INFO *GetOutputInfo(int Connection);
};
static unsigned short mid = 1;
#ifdef _DEBUG
#define DEBUG_STATE OutputDebugString(__FUNCTION__); OutputDebugString("\r\n");
#else
#define DEBUG_STATE
#endif
#define STATE userData->Info.last_state = last_state
#define LOCK if(WaitForSingleObject(mutex,INFINITE) == WAIT_OBJECT_0)
#define UNLOCK ReleaseMutex(mutex);
extern char sourceVersion[64];
extern HWND hMainDLG;
#endif // !__SHOUTCAST_OUTPUT_H__
Reference in New Issue View Git Blame Copy Permalink