5804 lines
220 KiB
C++
5804 lines
220 KiB
C++
// These are disabled for now they have unknown issues.
|
|
//#define USE_OGG
|
|
//#define CAPTURE_TESTING
|
|
|
|
// TODO / BE NICE FOR FUTURE VERSIONS
|
|
// 1) Fix capture issues on Vista / Windows 7
|
|
// 2) Allow metadata to be specified from file
|
|
// 3) Move over to using enc_lame (and ui changes for it) [partial]
|
|
|
|
#define APP_Name "Shoutcast Source"
|
|
#define APP_Version "2.4.2"
|
|
#define APP_VersionW L"2.4.2"
|
|
#define APP_Build "449"
|
|
|
|
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <stdio.h>
|
|
#include <shlobj.h>
|
|
#include <shellapi.h>
|
|
#include <shlwapi.h>
|
|
#include <commdlg.h>
|
|
#include <math.h>
|
|
#include <mmdeviceapi.h>
|
|
#include <audioclient.h>
|
|
#include <endpointvolume.h>
|
|
#include <functiondiscoverykeys.h>
|
|
#ifdef CAPTURE_TESTING
|
|
#include "Wasapi/WASAPICapture.h"
|
|
#endif
|
|
#include "resource/resource.h"
|
|
#include "sc2srclib/include/shoutcast_output.h"
|
|
#include "sc2srclib/encoders/c_encoder_mp3dll.h"
|
|
#include "sc2srclib/encoders/c_encoder_nsv.h"
|
|
#include "sc2srclib/encoders/c_encoder_fhgaac.h"
|
|
#include "sc2srclib/encoders/c_encoder_aacp.h"
|
|
#ifdef USE_OGG
|
|
#include "sc2srclib/Encoders/c_encoder_ogg.h"
|
|
#endif
|
|
// allows us to compile with the Wasabi sdk without having to change things
|
|
//#define __WASABI_TYPES_H
|
|
//#define _GUID_H
|
|
//typedef unsigned long ARGB32;
|
|
//static const GUID INVALID_GUID = { 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0} };
|
|
#include "api.h"
|
|
#include "include/c_wavein.h"
|
|
#include "crossfader/c_crossfader.h"
|
|
#include <winamp/wa_ipc.h>
|
|
#include <winamp/dsp.h>
|
|
#include "nu/servicebuilder.h"
|
|
#include "utils.h"
|
|
#ifdef CAPTURE_TESTING
|
|
#include "wasapi/player.h"
|
|
#endif
|
|
#include <strsafe.h>
|
|
|
|
#define NUM_OUTPUTS 5
|
|
#define NUM_ENCODERS NUM_OUTPUTS
|
|
#define NUM_BUFFERS 3
|
|
#define MAX_TABWNDS 4
|
|
#define MAX_COLS 6
|
|
#define MAX_CELLS 12
|
|
#define MAX_INWNDS 2
|
|
#define MAX_OUTWNDS 6
|
|
#define SYSTRAY_BASE_ICON 1024
|
|
#define SYSTRAY_ICY_ICON 1
|
|
#define SYSTRAY_BASE_MSG WM_USER
|
|
#define SYSTRAY_MAXIMIZE_MSG 27
|
|
#define DEFAULT_INPUTDEVICE 0 // winamp
|
|
|
|
#define DOWNLOAD_URL L"http://www.shoutcast.com/BroadcastNow"
|
|
// 404, change to one of these?
|
|
// #define DOWNLOAD_URL L"http://wiki.shoutcast.com/wiki/Source_DSP_Plug-in"
|
|
// #define DOWNLOAD_URL L"http://www.shoutcast.com"
|
|
|
|
char sourceVersion[64] = {APP_Version "." APP_Build};
|
|
static char szDescription[256];
|
|
static char szDescription2[256];
|
|
static wchar_t szDescription2W[256];
|
|
|
|
#ifdef CAPTURE_TESTING
|
|
static Player *pPlayer = NULL;
|
|
|
|
//
|
|
// The Player object calls the methods in this class to
|
|
// notify the application when certain audio events occur.
|
|
//
|
|
class CPlayerCallbacks : public PlayerCallbacks
|
|
{
|
|
// Notification callback for volume change. Typically, the user
|
|
// adjusts the volume through the SndVol.exe application.
|
|
void VolumeChangeCallback(float volume, BOOL mute)
|
|
{
|
|
/*EnableWindowDlgItem(g_hDlg, IDC_SLIDER_VOLUME, TRUE);
|
|
SetWindowText(GetDlgItem(g_hDlg, IDC_STATIC_MUTE),
|
|
(mute == TRUE) ? L"Mute" : L"");
|
|
PostMessage(GetDlgItem(g_hDlg, IDC_SLIDER_VOLUME),
|
|
TBM_SETPOS, TRUE, LPARAM(volume*MAX_VOLUME_LEVEL));*/
|
|
};
|
|
|
|
// Notification callback for when stream stops playing unexpectedly
|
|
// (typically, because the player reached the end of a wave file).
|
|
void PlayerStopCallback(void)
|
|
{
|
|
/*SetActiveWindow(g_hDlg);
|
|
PostMessage(GetDlgItem(g_hDlg, IDC_BUTTON_STOP), BM_CLICK, 0, 0);*/
|
|
};
|
|
|
|
// Notification callback for when the endpoint capture device is
|
|
// disconnected (for example, the user pulls out the microphone plug).
|
|
void CaptureDisconnectCallback(void)
|
|
{
|
|
/*SetWindowText(GetDlgItem(g_hDlg, IDC_STATIC_LASTACTION),
|
|
L"Capture device disconnected!");
|
|
SendMessage(GetDlgItem(g_hDlg, IDC_COMBO_CAPTUREDEVICE), CB_RESETCONTENT, 0, 0);*/
|
|
};
|
|
|
|
// Notification callback for when the endpoint rendering device is
|
|
// disconnected (for example, the user pulls out the headphones plug).
|
|
void RenderDisconnectCallback(void)
|
|
{
|
|
/*SetWindowText(GetDlgItem(g_hDlg, IDC_STATIC_LASTACTION),
|
|
L"Playback device disconnected!");
|
|
EnableWindowDlgItem(g_hDlg, IDC_SLIDER_VOLUME, FALSE);
|
|
SetWindowTextW(GetDlgItem(g_hDlg, IDC_STATIC_MUTE), L"Disconnected");
|
|
SendMessage(GetDlgItem(g_hDlg, IDC_COMBO_RENDERDEVICE), CB_RESETCONTENT, 0, 0);
|
|
SendMessage(GetDlgItem(g_hDlg, IDC_SLIDER_VOLUME), TBM_SETPOS, TRUE, 0);*/
|
|
};
|
|
};
|
|
|
|
|
|
static CPlayerCallbacks *pCallbacks = NULL;
|
|
#endif
|
|
|
|
// this is used to help determine if we're running on an older
|
|
// version of Winamp where jnetlib has issues with the re-use
|
|
// of connection handles when the connection previously failed
|
|
int iscompatibility = 0;
|
|
// used for the about page link so we don't cause win2k issues
|
|
int isthemethere = 0;
|
|
// Wasabi based services for localisation support
|
|
api_service *WASABI_API_SVC = 0;
|
|
api_config *AGAVE_API_CONFIG = 0;
|
|
api_language *WASABI_API_LNG = 0;
|
|
api_queue *WASABI_API_QUEUEMGR = 0;
|
|
api_albumart *AGAVE_API_ALBUMART = 0;
|
|
api_memmgr *WASABI_API_MEMMGR = 0;
|
|
api_explorerfindfile* WASABI_API_EXPLORERFINDFILE = 0;
|
|
api_downloadManager *WAC_API_DOWNLOADMANAGER = 0;
|
|
|
|
// these two must be declared as they're used by the language api's
|
|
// when the system is comparing/loading the different resources
|
|
HINSTANCE WASABI_API_LNG_HINST = 0,
|
|
WASABI_API_ORIG_HINST = 0;
|
|
HFONT boldFont = 0, normalFont = 0;
|
|
HICON icy = 0, wa_icy = 0;
|
|
static HHOOK nowPlayingHook,
|
|
nowPlayingHook2;
|
|
static LPARAM nowPlayingID = -1;
|
|
// just using these to track the paused and playing states
|
|
int was_paused = 0,
|
|
was_playing = 0;
|
|
DWORD play_duration = 0,
|
|
play_diff = 0;
|
|
int isplaying = -1, ptt_load = 0;
|
|
static wchar_t lastFile[MAX_PATH];
|
|
int lastFilterIndex = 4;
|
|
static int lastSec[NUM_OUTPUTS],
|
|
lastMode[NUM_OUTPUTS] = {-1, -1, -1, -1, -1},
|
|
lastEnable[NUM_OUTPUTS];
|
|
|
|
static HWND buttonWnd[ NUM_OUTPUTS ];
|
|
static HWND tabWnd;
|
|
static HWND outTabWnd;
|
|
static HWND updateWnd;
|
|
|
|
static ARGB32 *playingImage;
|
|
static ARGB32 *streamImage[NUM_OUTPUTS] = {(ARGB32 *)-1, (ARGB32 *)-1, (ARGB32 *)-1, (ARGB32 *)-1, (ARGB32 *)-1};
|
|
static int playingImage_w, playingImage_h, playingLength, playingType;
|
|
static int streamLength[NUM_OUTPUTS];
|
|
static bool secChanged[NUM_OUTPUTS];
|
|
void Config(struct winampDSPModule *this_mod);
|
|
int Init(struct winampDSPModule *this_mod);
|
|
int ModifySamples(struct winampDSPModule *this_mod, short int *samples, int numsamples, int bps, int nch, int srate);
|
|
void Quit(struct winampDSPModule *this_mod);
|
|
int secureFunc(int key){
|
|
int res = key * (unsigned long)1103515245;
|
|
res += (unsigned long)13293;
|
|
res &= (unsigned long)0x7FFFFFFF;
|
|
res ^= key;
|
|
return res;
|
|
}
|
|
winampDSPModule *getModule(int which);
|
|
winampDSPModule module = {
|
|
"nullsoft(dsp_sc.dll)",
|
|
NULL,
|
|
NULL,
|
|
Config,
|
|
Init,
|
|
ModifySamples,
|
|
Quit,
|
|
NULL
|
|
};
|
|
|
|
winampDSPHeader header = {
|
|
DSP_HDRVER+1,
|
|
"Nullsoft " APP_Name " DSP " APP_Version,
|
|
getModule,
|
|
secureFunc
|
|
};
|
|
|
|
|
|
static ARGB32 * writeImg(const ARGB32 *data, int w, int h, int *length, const wchar_t *ext) {
|
|
if (!ext || ext && !*ext) return NULL;
|
|
if (*ext == L'.') ext++;
|
|
FOURCC imgwrite = svc_imageWriter::getServiceType();
|
|
int n = WASABI_API_SVC->service_getNumServices(imgwrite);
|
|
for (int i=0; i<n; i++) {
|
|
waServiceFactory *sf = WASABI_API_SVC->service_enumService(imgwrite,i);
|
|
if (sf) {
|
|
svc_imageWriter * l = (svc_imageWriter*)sf->getInterface();
|
|
if (l) {
|
|
if (wcsstr(l->getExtensions(),ext)) {
|
|
void* ret = l->convert(data, 32, w, h, length);
|
|
sf->releaseInterface(l);
|
|
return (ARGB32 *)ret;
|
|
}
|
|
sf->releaseInterface(l);
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
HICON GetICYIcon(bool winamp = false) {
|
|
if (!winamp) {
|
|
if (!icy) {
|
|
icy = (HICON)LoadImage(WASABI_API_ORIG_HINST?WASABI_API_ORIG_HINST:module.hDllInstance,
|
|
MAKEINTRESOURCE(IDI_ICY), IMAGE_ICON, 0, 0,
|
|
LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION);
|
|
}
|
|
return icy;
|
|
} else {
|
|
if (!wa_icy) {
|
|
wa_icy = (HICON)LoadImage(GetModuleHandle("winamp.exe"),
|
|
MAKEINTRESOURCE(102), IMAGE_ICON, 0, 0,
|
|
LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION);
|
|
}
|
|
return (wa_icy ? wa_icy : icy);
|
|
}
|
|
}
|
|
|
|
BOOL InitLocalisation(HWND winamp) {
|
|
// if this is valid then we should be running on Winamp 5.5+ so try to get the localisation api
|
|
if (IsWindow(winamp)) {
|
|
iscompatibility = 1; ////// SendMessage( winamp, WM_WA_IPC, 0, IPC_IS_COMPATIBILITY_ENABLED );
|
|
isthemethere = !SendMessage(winamp, WM_WA_IPC, IPC_ISWINTHEMEPRESENT, IPC_USE_UXTHEME_FUNC);
|
|
if (!WASABI_API_LNG_HINST) {
|
|
// loader so that we can get the localisation service api for use
|
|
WASABI_API_SVC = (api_service*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GET_API_SERVICE);
|
|
if (WASABI_API_SVC == (api_service*)1) {
|
|
WASABI_API_SVC = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
// initialise all of the wasabi based services
|
|
ServiceBuild(WASABI_API_SVC, AGAVE_API_CONFIG, AgaveConfigGUID);
|
|
ServiceBuild(WASABI_API_SVC, WASABI_API_LNG, languageApiGUID);
|
|
ServiceBuild(WASABI_API_SVC, WASABI_API_MEMMGR, memMgrApiServiceGuid);
|
|
ServiceBuild(WASABI_API_SVC, AGAVE_API_ALBUMART, albumArtGUID);
|
|
ServiceBuild(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
|
|
ServiceBuild(WASABI_API_SVC, WASABI_API_EXPLORERFINDFILE, ExplorerFindFileApiGUID);
|
|
ServiceBuild(WASABI_API_SVC, WAC_API_DOWNLOADMANAGER, DownloadManagerGUID);
|
|
|
|
// need to have this initialised before we try to do anything with localisation features
|
|
WASABI_API_START_LANG(GetMyInstance(), DspShoutcastLangGUID);
|
|
|
|
// do this here so if there is no localisation support then the module names go to defaults
|
|
if (!szDescription[0]) {
|
|
StringCchPrintfA(szDescription, ARRAYSIZE(szDescription), LocalisedStringA(IDS_PLUGIN_NAME, NULL, 0), APP_Version);
|
|
header.description = szDescription;
|
|
}
|
|
|
|
if (!szDescription2[0]) {
|
|
module.description = LocalisedStringA(IDS_MODULE_NAME, szDescription2, 256);
|
|
LocalisedString(IDS_MODULE_NAME, szDescription2W, 256);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
__declspec(dllexport) winampDSPHeader *winampDSPGetHeader2(HWND hwndParent) {
|
|
if (InitLocalisation(hwndParent)) {
|
|
return &header;
|
|
}
|
|
MessageBoxA(module.hwndParent,
|
|
"You are attempting to use the " APP_Name " plug-in in an\n"
|
|
"unsupported version of Winamp or in a non-Winamp install or via a\n"
|
|
"DSP stacker which does not implement the Winamp 5.5+ DSP api.\n\n"
|
|
"To work this plug-in requires Winamp 5.5 and higher (the most current\n"
|
|
"release is recommended) or for the non-Winamp install or DSP stacker\n"
|
|
"to be updated to support the required Winamp api's the plug-in uses.",
|
|
"Nullsoft " APP_Name, MB_ICONEXCLAMATION|MB_APPLMODAL);
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) int winampUninstallPlugin(HINSTANCE hDllInst, HWND hwndDlg, int param) {
|
|
// this isn't ideal but it ensures that we show a localised version of the message
|
|
// if not it'll make sure that we're using the plug-in dll's internal resources
|
|
// though for ease of code handling we have to fill in some of the dsp structures
|
|
// as the plug-in has effectively been unloaded at this stage for the uninstall.
|
|
HWND winamp = GetWinampHWND(0);
|
|
module.hDllInstance = hDllInst;
|
|
module.hwndParent = winamp;
|
|
InitLocalisation(winamp);
|
|
|
|
wchar_t title[256] = {0};
|
|
StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_Version);
|
|
|
|
// prompt to remove the settings files (defaults to no just incase)
|
|
if (MessageBoxW(hwndDlg, LocalisedString(IDS_PLUGIN_UNINSTALL, NULL, 0), title, MB_YESNO|MB_DEFBUTTON2) == IDYES) {
|
|
DeleteFile(GetSCIniFile(winamp));
|
|
}
|
|
return DSP_PLUGIN_UNINSTALL_NOW;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
winampDSPModule *getModule(int which) {
|
|
if (which == 0) return &module;
|
|
return NULL;
|
|
}
|
|
// Client's proprietary event-context GUID
|
|
//extern GUID g_guidMyContext;
|
|
|
|
// Maximum volume level on trackbar
|
|
#define MAX_VOL 100
|
|
|
|
#define SAFE_RELEASE(what) \
|
|
if ((what) != NULL) \
|
|
{ (what)->Release(); (what) = NULL; }
|
|
|
|
//GUID g_guidMyContext = GUID_NULL;
|
|
|
|
static IAudioStreamVolume *g_pStreamVol = NULL;
|
|
static IAudioEndpointVolume *g_pEndptVol = NULL;
|
|
static IAudioClient *g_pAudioClient = NULL;
|
|
static IAudioCaptureClient *g_pCaptureClient = NULL;
|
|
|
|
/*#define EXIT_ON_ERROR(hr) \
|
|
if (FAILED(hr)) { goto Exit; }
|
|
#define ERROR_CANCEL(hr) \
|
|
if (FAILED(hr)) { \
|
|
MessageBox(hDlg, TEXT("The program will exit."), \
|
|
TEXT("Fatal error"), MB_OK); \
|
|
EndDialog(hDlg, TRUE); return TRUE; }*/
|
|
|
|
HANDLE cf_mutex = NULL;
|
|
C_CROSSFADER *Crossfader = NULL;
|
|
int CrossfadeLen = 5000;
|
|
unsigned int Input_Device_ID=0;
|
|
int Restore_PTT = 0;
|
|
unsigned int numInputs=0;
|
|
char updateStr[16] = {0};
|
|
|
|
typedef struct {
|
|
// BladeEnc DLL Version number
|
|
BYTE byDLLMajorVersion;
|
|
BYTE byDLLMinorVersion;
|
|
// BladeEnc Engine Version Number
|
|
BYTE byMajorVersion;
|
|
BYTE byMinorVersion;
|
|
// DLL Release date
|
|
BYTE byDay;
|
|
BYTE byMonth;
|
|
WORD wYear;
|
|
// BladeEnc Homepage URL
|
|
#define BE_MAX_HOMEPAGE 128
|
|
CHAR zHomepage[BE_MAX_HOMEPAGE + 1];
|
|
BYTE byAlphaLevel;
|
|
BYTE byBetaLevel;
|
|
BYTE byMMXEnabled;
|
|
BYTE btReserved[125];
|
|
} BE_VERSION, *PBE_VERSION;
|
|
typedef VOID (*BEVERSION)(PBE_VERSION);
|
|
BEVERSION beVersion = NULL;
|
|
void *init = NULL;
|
|
void *params = NULL;
|
|
void *encode = NULL;
|
|
void *finish = NULL;
|
|
void *lameclose = NULL;
|
|
|
|
int CALLBACK DialogFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
HINSTANCE instance = NULL;
|
|
HINSTANCE libinst = NULL;
|
|
HWND hMainDLG = NULL;
|
|
RECT mainrect;
|
|
HWND inWin = NULL, inWinWa = NULL;
|
|
|
|
struct T_TABWND {
|
|
HWND hWnd;
|
|
int id;
|
|
int timer_freq;
|
|
TCITEMW tcitem;
|
|
} wnd[MAX_TABWNDS] = {0},
|
|
out_wnd[MAX_OUTWNDS] = {0};
|
|
int num_tabwnds = 0,
|
|
num_outwnds = 0;
|
|
|
|
struct T_COL {
|
|
LVCOLUMNW lvcol;
|
|
LVITEMW lvitem[MAX_CELLS];
|
|
int num_cells;
|
|
} col[MAX_COLS] = {0};
|
|
int num_cols = 0;
|
|
|
|
struct T_INPUTWND{
|
|
HWND hWnd;
|
|
int id;
|
|
int timer_freq;
|
|
} in_wnd[MAX_INWNDS] = {0};
|
|
int num_inwnds = 0;
|
|
|
|
// shoutcast source
|
|
struct T_INPUT_CONFIG {
|
|
int srate;
|
|
int nch;
|
|
};
|
|
struct MY_T_OUTPUT {
|
|
T_OUTPUT_CONFIG Config;
|
|
int Encoder; // encoder this config is used by
|
|
int Handle; // handle that the encoder understands
|
|
int AutoTitle;
|
|
int AutoConnect;
|
|
int Logging;
|
|
int LogCOS;
|
|
int NextTitles;
|
|
int nextTrackLog;
|
|
int nextTrackLogXML;
|
|
wchar_t nextTrackPath[MAX_PATH];
|
|
int useArt;
|
|
int usePlayingArt;
|
|
int useStreamArt;
|
|
wchar_t stationArtPath[MAX_PATH];
|
|
int saveEncoded;
|
|
wchar_t saveEncodedPath[MAX_PATH];
|
|
} Output[NUM_OUTPUTS] = {0};
|
|
SHOUTCAST_OUTPUT Encoder[NUM_ENCODERS];
|
|
HANDLE Enc_mutex[NUM_ENCODERS] = {0};
|
|
int Enc_LastType[NUM_ENCODERS] = {0};
|
|
C_WAVEIN<NUM_BUFFERS, 5120 > Soundcard;
|
|
|
|
int last_buffer = 0;
|
|
int Connection_CurSelPos = 0;
|
|
int Encoder_CurSelPos = 0;
|
|
int Input_CurSelPos = 3;
|
|
int InputDevice = DEFAULT_INPUTDEVICE;
|
|
clock_t audiolag = 0;
|
|
clock_t lastaudio = 0;
|
|
int curtab = 1;
|
|
int curouttab = 0;
|
|
int lookAhead = 3;
|
|
bool skipMetada = false;
|
|
bool doNextLookAhead = false;
|
|
HANDLE hthread = NULL;
|
|
DWORD threadid = 0;
|
|
HANDLE hthreadout = NULL;
|
|
DWORD threadoutid = 0;
|
|
HWND hWinamp = NULL;
|
|
int ini_modified = 0;
|
|
HANDLE logFiles[NUM_OUTPUTS] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
|
|
|
|
struct T_VU {
|
|
int vu_l;
|
|
int vu_r;
|
|
int update;
|
|
int lastUpdate;
|
|
} VU;
|
|
int peak_vu_l = -90;
|
|
int peak_vu_r = -90;
|
|
|
|
T_INPUT_CONFIG InputConfig;
|
|
int MusVol = 9;
|
|
int Mus2Vol = 3;
|
|
int MicVol = 9;
|
|
int FadeTime = 20;
|
|
int MicFadeTime = 10; // mimic old behaviour with a faster fade up/down of the capture device
|
|
int devopts = 0;
|
|
clock_t FadeStartTime;
|
|
clock_t MicFadeStartTime;
|
|
int FadeOut = 0;
|
|
WNDPROC prevButtonProc = NULL,
|
|
prevListViewProc = NULL,
|
|
prevHeaderProc = NULL,
|
|
prevTabWndProc = NULL,
|
|
prevOutTabWndProc = NULL;
|
|
int blockmousemove = 0;
|
|
T_INPUT_CONFIG LineInputAttribs[]= {
|
|
{22050, 1},
|
|
{44100, 1},
|
|
{22050, 2},
|
|
{44100, 2},
|
|
};
|
|
|
|
void AddSystrayIcon(HWND hWnd, UINT uIconId, HICON hIcon, UINT uMsg, LPWSTR lpszToolTip) {
|
|
NOTIFYICONDATAW tnid = {0};
|
|
tnid.cbSize = sizeof (NOTIFYICONDATAW);
|
|
tnid.hWnd = hWnd;
|
|
tnid.uID = SYSTRAY_BASE_ICON + uIconId;
|
|
tnid.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;
|
|
tnid.uCallbackMessage = SYSTRAY_BASE_MSG + uMsg;
|
|
tnid.hIcon = hIcon;
|
|
wcsncpy(tnid.szTip, lpszToolTip, ARRAYSIZE(tnid.szTip));
|
|
Shell_NotifyIconW(NIM_ADD, &tnid);
|
|
return;
|
|
}
|
|
|
|
void RemoveSystrayIcon(HWND hWnd, UINT uIconId) {
|
|
NOTIFYICONDATAW tnid = {0};
|
|
tnid.cbSize = sizeof (NOTIFYICONDATAW);
|
|
tnid.hWnd = hWnd;
|
|
tnid.uID = SYSTRAY_BASE_ICON + uIconId;
|
|
Shell_NotifyIconW(NIM_DELETE, &tnid);
|
|
return;
|
|
}
|
|
|
|
void AddTab(int dialog_id, wchar_t *tab_name, HWND hWndParent, DLGPROC DlgProc, int tab_id, int rect_id, int timer_freq) {
|
|
RECT r = {0};
|
|
T_TABWND *twnd = &wnd[num_tabwnds];
|
|
GetWindowRect(GetDlgItem(hWndParent, rect_id), &r);
|
|
ScreenToClient(hWndParent, (POINT *) & r);
|
|
twnd->id = dialog_id;
|
|
twnd->timer_freq = timer_freq;
|
|
twnd->hWnd = LocalisedCreateDialog(instance, dialog_id, hWndParent, DlgProc, dialog_id);
|
|
ShowWindow(twnd->hWnd, SW_HIDE);
|
|
SetWindowPos(twnd->hWnd, NULL, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
|
|
twnd->tcitem.mask = TCIF_TEXT;
|
|
twnd->tcitem.pszText = tab_name;
|
|
twnd->tcitem.cchTextMax = wcslen(tab_name);
|
|
SendDlgItemMessage(hWndParent, tab_id, TCM_INSERTITEMW, num_tabwnds++, (LPARAM)&twnd->tcitem);
|
|
if (IsWindow(twnd->hWnd) && isthemethere) {
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)twnd->hWnd, IPC_USE_UXTHEME_FUNC);
|
|
}
|
|
}
|
|
|
|
void SetTab(int tabnum, HWND hWndParent, int tab_id) {
|
|
NMHDR nmh;
|
|
nmh.code = TCN_SELCHANGE;
|
|
nmh.hwndFrom = GetDlgItem(hWndParent, tab_id);
|
|
nmh.idFrom = tab_id;
|
|
curtab = tabnum;
|
|
SendMessage(nmh.hwndFrom, TCM_SETCURSEL, curtab, 0);
|
|
SendMessage(hWndParent, WM_NOTIFY, tab_id, (LPARAM) & nmh);
|
|
}
|
|
|
|
void AddInTab(int dialog_id, wchar_t *tab_name, HWND hWndParent) {
|
|
RECT r = {0};
|
|
T_INPUTWND *twnd = &in_wnd[num_inwnds++];
|
|
GetWindowRect(GetDlgItem(hWndParent, IDC_PANEL_RECT), &r);
|
|
ScreenToClient(hWndParent, (POINT *)&r);
|
|
twnd->id = dialog_id;
|
|
twnd->timer_freq = 0;
|
|
twnd->hWnd = LocalisedCreateDialog(instance, dialog_id, hWndParent, DialogFunc, dialog_id);
|
|
ShowWindow(twnd->hWnd, SW_HIDE);
|
|
SetWindowPos(twnd->hWnd, NULL, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
|
|
SendDlgItemMessageW(hWndParent, IDC_INPUTDEVICE, CB_ADDSTRING, 0, (LPARAM)tab_name);
|
|
if (IsWindow(twnd->hWnd) && isthemethere) {
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)twnd->hWnd, IPC_USE_UXTHEME_FUNC);
|
|
}
|
|
}
|
|
|
|
void SetInTab(int tabnum, HWND hWndParent, int combo_id) {
|
|
SendDlgItemMessage(hWndParent, combo_id, CB_SETCURSEL, tabnum, 0);
|
|
SendMessage(hWndParent, WM_COMMAND, MAKEWPARAM(combo_id, CBN_SELCHANGE), (LPARAM) GetDlgItem(hWndParent, combo_id));
|
|
}
|
|
|
|
void AddOutTab(int dialog_id, wchar_t *tab_name, HWND hWndParent, DLGPROC DlgProc, int tab_id, int rect_id, int timer_freq) {
|
|
RECT r = {0};
|
|
T_TABWND *twnd = &out_wnd[num_outwnds];
|
|
GetWindowRect(GetDlgItem(hWndParent, IDC_PANELRECT_C), &r);
|
|
ScreenToClient(hWndParent, (POINT *)&r);
|
|
twnd->id = dialog_id;
|
|
twnd->timer_freq = 0;
|
|
twnd->hWnd = LocalisedCreateDialog(instance, dialog_id, hWndParent, DlgProc, dialog_id);
|
|
ShowWindow(twnd->hWnd, SW_HIDE);
|
|
SetWindowPos(twnd->hWnd, NULL, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
|
|
twnd->tcitem.mask = TCIF_TEXT;
|
|
twnd->tcitem.pszText = tab_name;
|
|
twnd->tcitem.cchTextMax = wcslen(tab_name);
|
|
SendDlgItemMessageW(hWndParent, IDC_CONTAB, TCM_INSERTITEMW, num_outwnds++, (LPARAM) & twnd->tcitem);
|
|
if (IsWindow(twnd->hWnd) && isthemethere) {
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)twnd->hWnd, IPC_USE_UXTHEME_FUNC);
|
|
}
|
|
}
|
|
|
|
void SetOutTab(int tabnum, HWND hWndParent, int tab_id) {
|
|
NMHDR nmh;
|
|
nmh.code = TCN_SELCHANGE;
|
|
nmh.hwndFrom = GetDlgItem(hWndParent, tab_id);
|
|
nmh.idFrom = tab_id;
|
|
curouttab = tabnum;
|
|
SendMessage(nmh.hwndFrom, TCM_SETCURSEL, curouttab, 0);
|
|
SendMessage(hWndParent, WM_NOTIFY, tab_id, (LPARAM) & nmh);
|
|
}
|
|
|
|
void AddColumn(wchar_t *column_text, HWND listView) {
|
|
T_COL *tcol = &col[num_cols];
|
|
tcol->lvcol.mask = LVCF_TEXT;
|
|
tcol->lvcol.pszText = column_text;
|
|
tcol->lvcol.cchTextMax = wcslen(column_text);
|
|
SendMessageW(listView, LVM_INSERTCOLUMNW, num_cols++, (LPARAM)&tcol->lvcol);
|
|
}
|
|
|
|
void AddColItem(wchar_t *cell_text, int colnum, HWND hWndParent, int list_id, int pos = -1) {
|
|
LVITEMW *tcell = &col[colnum].lvitem[col[colnum].num_cells];
|
|
tcell->mask = TVIF_TEXT;
|
|
tcell->iItem = pos == -1 ? col[colnum].num_cells++ : pos;
|
|
tcell->iSubItem = colnum;
|
|
tcell->pszText = cell_text;
|
|
tcell->cchTextMax = wcslen(cell_text);
|
|
SendDlgItemMessageW(hWndParent, list_id, pos == -1 && colnum == 0 ? LVM_INSERTITEMW : LVM_SETITEMW, 0, (LPARAM)tcell);
|
|
}
|
|
|
|
void __inline interleave_buffer(const short * inLeft, short *outputbuf, const size_t num_samples) {
|
|
for (size_t i = 0; i < num_samples; ++i) {
|
|
outputbuf[i * 2] = inLeft[i];
|
|
outputbuf[i * 2 + 1] = inLeft[i];
|
|
}
|
|
}
|
|
|
|
DWORD WINAPI ThreadInput(LPVOID lpParameter) {
|
|
do {
|
|
// this is needed when doing soundcard capture
|
|
if (InputDevice == 1) DialogFunc((HWND) lpParameter, WM_TIMER, MAKEWPARAM(1234,0), 0);
|
|
short mybuf[32768] = {0};
|
|
size_t mysamps = 0;
|
|
|
|
if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
|
|
if (Input_CurSelPos != -1) {
|
|
if (InputDevice == 0) {
|
|
if (isplaying != 1) {
|
|
// when stopped or paused, we need to pump silent output
|
|
// and from testing, sending 2 emtpy samples appears to
|
|
// keep the output bitrate about the same as playback's
|
|
mysamps = sizeof(mybuf)/8;
|
|
} else {
|
|
mysamps = Crossfader->get(mybuf, sizeof (mybuf) / (InputConfig.nch * sizeof (short)), InputConfig.nch) * InputConfig.nch;
|
|
}
|
|
} else {
|
|
int samps = (LineInputAttribs[Input_CurSelPos].nch * sizeof (short));
|
|
if(LineInputAttribs[Input_CurSelPos].nch == 1) {
|
|
mysamps = Crossfader->get(mybuf, (samps ? sizeof (mybuf) / samps : sizeof (mybuf)) / 2, LineInputAttribs[Input_CurSelPos].nch) * LineInputAttribs[Input_CurSelPos].nch;
|
|
short *newbuf = (short*) malloc(mysamps * 2 * sizeof(short));
|
|
interleave_buffer(mybuf, newbuf, mysamps);
|
|
mysamps *= 2;
|
|
memcpy(mybuf, newbuf, mysamps * sizeof (short));
|
|
free(newbuf);
|
|
} else {
|
|
mysamps = Crossfader->get(mybuf, (samps ? sizeof (mybuf) / samps : sizeof (mybuf)), LineInputAttribs[Input_CurSelPos].nch) * LineInputAttribs[Input_CurSelPos].nch;
|
|
}
|
|
}
|
|
}
|
|
ReleaseMutex(cf_mutex);
|
|
}
|
|
|
|
if (mysamps > 0) {
|
|
short *tmp = mybuf;
|
|
for (size_t k = 0; k != NUM_ENCODERS; k++) {
|
|
if (WaitForSingleObject(Enc_mutex[k], INFINITE) == WAIT_OBJECT_0) {
|
|
size_t size = mysamps * sizeof (short);
|
|
short * newbuf = (short*) malloc(size);
|
|
if (newbuf) {
|
|
memcpy(newbuf, tmp, size);
|
|
Encoder[k].Run(OM_ENCODE, newbuf, size, k); // this seems to be modifying newbuf
|
|
free(newbuf);
|
|
}
|
|
ReleaseMutex(Enc_mutex[k]);
|
|
}
|
|
}
|
|
}
|
|
Sleep(25);
|
|
} while (hthread != NULL);
|
|
return 0;
|
|
}
|
|
|
|
DWORD WINAPI ThreadOutput(LPVOID lpParameter) {
|
|
do {
|
|
for (int k = 0; k < NUM_ENCODERS; k++) {
|
|
if (WaitForSingleObject(Enc_mutex[k], 25) == WAIT_OBJECT_0) {
|
|
if (Encoder[k].GetEncoder()) {
|
|
Encoder[k].Run(OM_OUTPUT | OM_OTHER);
|
|
}
|
|
ReleaseMutex(Enc_mutex[k]);
|
|
}
|
|
}
|
|
Sleep(25);
|
|
} while (hthreadout != NULL);
|
|
return 0;
|
|
}
|
|
|
|
char olddev[256] = {0};
|
|
int DisplayDeviceName(void) {
|
|
if (InputDevice) {
|
|
char deviceBuf[256] = {0};
|
|
char *deviceName = Soundcard.getDeviceName(0);
|
|
|
|
if (deviceName && *deviceName) {
|
|
char tmp[128] = {0};
|
|
StringCchPrintfA(deviceBuf, ARRAYSIZE(deviceBuf), WASABI_API_LNGSTRING_BUF(IDS_DEVICE_STRING, tmp, 128), deviceName);
|
|
} else {
|
|
WASABI_API_LNGSTRING_BUF(IDS_NO_DEVICES_FOUND, deviceBuf, ARRAYSIZE(deviceBuf));
|
|
olddev[0] = 0;
|
|
}
|
|
SendDlgItemMessage(wnd[2].hWnd, IDC_CURDEVICE, WM_SETTEXT, 0,(LPARAM)deviceBuf);
|
|
|
|
// vista - 7 check for default device and restart soundcard if needed
|
|
if (IsVistaUp()) {
|
|
if (strcmp(deviceBuf, olddev) != 0) {
|
|
lstrcpyn(olddev, deviceBuf, ARRAYSIZE(olddev));
|
|
SuspendThread(hthread);
|
|
Soundcard.Close();
|
|
Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
|
|
ResumeThread(hthread);
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
} else {
|
|
SendDlgItemMessage(wnd[2].hWnd, IDC_CURDEVICE, WM_SETTEXT, 0,(LPARAM)"");
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
#ifdef CAPTURE_TESTING
|
|
//-----------------------------------------------------------
|
|
// The input argument to this function is a pointer to the
|
|
// IMMDevice interface for a capture endpoint device. The
|
|
// function traverses the data path that extends from the
|
|
// endpoint device to the system bus (for example, PCI)
|
|
// or external bus (USB). If the function discovers a MUX
|
|
// (input selector) in the path, it selects the MUX input
|
|
// that connects to the stream from the endpoint device.
|
|
//-----------------------------------------------------------
|
|
#define EXIT_ON_ERROR(hres) \
|
|
if (FAILED(hres)) { goto Exit; }
|
|
#define SAFE_RELEASE(punk) \
|
|
if ((punk) != NULL) \
|
|
{ (punk)->Release(); (punk) = NULL; }
|
|
|
|
const IID IID_IDeviceTopology = __uuidof(IDeviceTopology);
|
|
const IID IID_IPart = __uuidof(IPart);
|
|
const IID IID_IConnector = __uuidof(IConnector);
|
|
const IID IID_IAudioInputSelector = __uuidof(IAudioInputSelector);
|
|
|
|
HRESULT SelectCaptureDevice(IMMDevice *pEndptDev)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DataFlow flow;
|
|
IDeviceTopology *pDeviceTopology = NULL;
|
|
IConnector *pConnFrom = NULL;
|
|
IConnector *pConnTo = NULL;
|
|
IPart *pPartPrev = NULL;
|
|
IPart *pPartNext = NULL;
|
|
IAudioInputSelector *pSelector = NULL;
|
|
|
|
if (pEndptDev == NULL)
|
|
{
|
|
EXIT_ON_ERROR(hr = E_POINTER)
|
|
}
|
|
|
|
// Get the endpoint device's IDeviceTopology interface.
|
|
hr = pEndptDev->Activate(
|
|
IID_IDeviceTopology, CLSCTX_ALL, NULL,
|
|
(void**)&pDeviceTopology);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
// The device topology for an endpoint device always
|
|
// contains just one connector (connector number 0).
|
|
hr = pDeviceTopology->GetConnector(0, &pConnFrom);
|
|
SAFE_RELEASE(pDeviceTopology)
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
// Make sure that this is a capture device.
|
|
hr = pConnFrom->GetDataFlow(&flow);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
if (flow != Out)
|
|
{
|
|
// Error -- this is a rendering device.
|
|
EXIT_ON_ERROR(hr = AUDCLNT_E_WRONG_ENDPOINT_TYPE)
|
|
}
|
|
|
|
// Outer loop: Each iteration traverses the data path
|
|
// through a device topology starting at the input
|
|
// connector and ending at the output connector.
|
|
while (TRUE)
|
|
{
|
|
BOOL bConnected;
|
|
hr = pConnFrom->IsConnected(&bConnected);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
// Does this connector connect to another device?
|
|
if (bConnected == FALSE)
|
|
{
|
|
// This is the end of the data path that
|
|
// stretches from the endpoint device to the
|
|
// system bus or external bus. Verify that
|
|
// the connection type is Software_IO.
|
|
ConnectorType connType;
|
|
hr = pConnFrom->GetType(&connType);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
if (connType == Software_IO)
|
|
{
|
|
break; // finished
|
|
}
|
|
EXIT_ON_ERROR(hr = E_FAIL)
|
|
}
|
|
|
|
// Get the connector in the next device topology,
|
|
// which lies on the other side of the connection.
|
|
hr = pConnFrom->GetConnectedTo(&pConnTo);
|
|
EXIT_ON_ERROR(hr)
|
|
SAFE_RELEASE(pConnFrom)
|
|
|
|
// Get the connector's IPart interface.
|
|
hr = pConnTo->QueryInterface(
|
|
IID_IPart, (void**)&pPartPrev);
|
|
EXIT_ON_ERROR(hr)
|
|
SAFE_RELEASE(pConnTo)
|
|
|
|
// Inner loop: Each iteration traverses one link in a
|
|
// device topology and looks for input multiplexers.
|
|
while (TRUE)
|
|
{
|
|
PartType parttype;
|
|
UINT localId;
|
|
IPartsList *pParts;
|
|
|
|
// Follow downstream link to next part.
|
|
hr = pPartPrev->EnumPartsOutgoing(&pParts);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pParts->GetPart(0, &pPartNext);
|
|
pParts->Release();
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pPartNext->GetPartType(&parttype);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
if (parttype == Connector)
|
|
{
|
|
// We've reached the output connector that
|
|
// lies at the end of this device topology.
|
|
hr = pPartNext->QueryInterface(
|
|
IID_IConnector,
|
|
(void**)&pConnFrom);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
SAFE_RELEASE(pPartPrev)
|
|
SAFE_RELEASE(pPartNext)
|
|
break;
|
|
}
|
|
|
|
// Failure of the following call means only that
|
|
// the part is not a MUX (input selector).
|
|
hr = pPartNext->Activate(
|
|
CLSCTX_ALL,
|
|
IID_IAudioInputSelector,
|
|
(void**)&pSelector);
|
|
if (hr == S_OK)
|
|
{
|
|
// We found a MUX (input selector), so select
|
|
// the input from our endpoint device.
|
|
hr = pPartPrev->GetLocalId(&localId);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pSelector->SetSelection(localId, NULL);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
SAFE_RELEASE(pSelector)
|
|
}
|
|
|
|
SAFE_RELEASE(pPartPrev)
|
|
pPartPrev = pPartNext;
|
|
pPartNext = NULL;
|
|
}
|
|
}
|
|
|
|
Exit:
|
|
SAFE_RELEASE(pConnFrom)
|
|
SAFE_RELEASE(pConnTo)
|
|
SAFE_RELEASE(pPartPrev)
|
|
SAFE_RELEASE(pPartNext)
|
|
SAFE_RELEASE(pSelector)
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
void setlev(int cs, int va) {
|
|
if (IsVistaUp() &&
|
|
(cs == MIXERLINE_COMPONENTTYPE_SRC_LINE || cs == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE)) {
|
|
//HRESULT hr = S_OK;
|
|
IMMDeviceEnumerator *pEnumerator = NULL;
|
|
IMMDevice *pDevice = NULL;
|
|
IMMDeviceCollection *ppDevices = NULL;
|
|
//hr = CoCreateGuid(&g_guidMyContext);
|
|
//EXIT_ON_ERROR(hr)
|
|
|
|
// Get enumerator for audio endpoint devices.
|
|
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
|
HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
|
|
NULL, CLSCTX_INPROC_SERVER,
|
|
__uuidof(IMMDeviceEnumerator),
|
|
(void**)&pEnumerator);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pEnumerator->EnumAudioEndpoints(eCapture, DEVICE_STATE_ACTIVE | DEVICE_STATE_UNPLUGGED, &ppDevices);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = ppDevices->Item(Input_Device_ID, &pDevice);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
//activate
|
|
hr = pDevice->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, (void**)&g_pEndptVol);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
//set mic volume
|
|
float fVolume = (float)(va / 100.0f);
|
|
if (va > 2) {
|
|
hr = g_pEndptVol->SetMasterVolumeLevelScalar(fVolume, NULL/*&g_guidMyContext*/);
|
|
EXIT_ON_ERROR(hr)
|
|
} else {//mute
|
|
hr = g_pEndptVol->SetMasterVolumeLevelScalar((float)0.0f, NULL/*&g_guidMyContext*/);
|
|
}
|
|
|
|
/*hr = pDevice->Activate(__uuidof(IAudioStreamVolume ), CLSCTX_ALL, NULL, (void**)&g_pStreamVol);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
g_pStreamVol->SetChannelVolume(0, fVolume);
|
|
g_pStreamVol->SetChannelVolume(1, fVolume);
|
|
|
|
IMMDevice *pDefaultDevice = NULL;
|
|
hr = pEnumerator->GetDefaultAudioEndpoint(eCapture,eConsole,&pDefaultDevice);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pDefaultDevice->Activate(__uuidof(IAudioStreamVolume ), CLSCTX_ALL, NULL, (void**)&g_pStreamVol);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
g_pStreamVol->SetChannelVolume(0, fVolume);
|
|
g_pStreamVol->SetChannelVolume(1, fVolume);*/
|
|
|
|
Exit:
|
|
SAFE_RELEASE(pEnumerator)
|
|
SAFE_RELEASE(pDevice)
|
|
SAFE_RELEASE(ppDevices)
|
|
SAFE_RELEASE(g_pEndptVol)
|
|
CoUninitialize();
|
|
} // end if mic
|
|
|
|
for (UINT i = 0; i < (IsVistaUp() ? mixerGetNumDevs() : 1); i++) {
|
|
HMIXER hmix;
|
|
#ifdef FOLLOW_MIXER
|
|
// TODO use a different handle??
|
|
mixerOpen(&hmix, i, (DWORD_PTR)hMainDLG, 0, MIXER_OBJECTF_MIXER|CALLBACK_WINDOW);
|
|
#endif
|
|
if (mixerOpen(&hmix, i, (DWORD_PTR)hMainDLG, 0, MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
|
|
MIXERLINE ml = {sizeof (ml), 0};
|
|
ml.dwComponentType = cs;
|
|
if (mixerGetLineInfo((HMIXEROBJ) hmix, &ml, MIXER_GETLINEINFOF_COMPONENTTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
|
|
MIXERLINECONTROLS mlc = {sizeof (mlc), ml.dwLineID,};
|
|
MIXERCONTROL mc = {sizeof (mc),};
|
|
mlc.cControls = 1;
|
|
mlc.cbmxctrl = sizeof (mc);
|
|
mlc.pamxctrl = &mc;
|
|
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
|
|
if (mixerGetLineControls((HMIXEROBJ) hmix, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
|
|
MIXERCONTROLDETAILS mcd = {sizeof (mcd), mc.dwControlID, ml.cChannels,};
|
|
MIXERCONTROLDETAILS_UNSIGNED v[2];
|
|
mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED);
|
|
mcd.paDetails = v;
|
|
v[0].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
|
|
v[1].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
|
|
/*MMRESULT result = */mixerSetControlDetails((HMIXEROBJ) hmix, &mcd, MIXER_OBJECTF_MIXER);
|
|
}
|
|
}
|
|
mixerClose(hmix);
|
|
}
|
|
}
|
|
|
|
DisplayDeviceName();
|
|
}
|
|
|
|
int SetDeviceName(void) {
|
|
HRESULT hr = S_OK;
|
|
IMMDeviceEnumerator *pEnumerate = NULL;
|
|
IMMDevice *pDevice = NULL;
|
|
IMMDevice *pDefaultDevice = NULL;
|
|
IMMDeviceCollection *ppDevices = NULL;
|
|
IPropertyStore *pProps = NULL;
|
|
PROPVARIANT varName;
|
|
|
|
if (IsVistaUp()) {
|
|
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
|
PropVariantInit(&varName);
|
|
// Get enumerator for audio endpoint devices.
|
|
hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
|
|
NULL, CLSCTX_INPROC_SERVER,
|
|
__uuidof(IMMDeviceEnumerator),
|
|
(void**)&pEnumerate);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pEnumerate->EnumAudioEndpoints(eCapture, DEVICE_STATE_ACTIVE | DEVICE_STATE_UNPLUGGED, &ppDevices);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
numInputs = 0;
|
|
hr = ppDevices->GetCount(&numInputs);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
// treat this as a dummy stop
|
|
Exit:;
|
|
}
|
|
|
|
int oldCount = SendDlgItemMessage(inWin, IDC_DEVBOX, CB_GETCOUNT, 0, 0);
|
|
SendDlgItemMessage(inWin, IDC_DEVBOX, CB_RESETCONTENT, 0,0);
|
|
EnableWindowDlgItem(inWin, IDC_REFRESH_DEVICES, IsVistaUp());
|
|
|
|
if (!IsVistaUp()) {//change back to true when vista enabled !
|
|
SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_MIC_LEGACY_MODE, NULL, 0));
|
|
SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_LINEIN_LEGACY_MODE, NULL, 0));
|
|
} else {
|
|
hr = pEnumerate->GetDefaultAudioEndpoint(eCapture, eConsole, &pDefaultDevice);
|
|
if (SUCCEEDED(hr) && pDefaultDevice != NULL) {
|
|
LPWSTR defaultName = NULL;
|
|
pDefaultDevice->GetId(&defaultName);
|
|
|
|
//jkey: This is for vista or 7, so we scan through and add friendly device names
|
|
// though need to make sure that we don't re-add the current input device
|
|
// otherwise with the waveout fudge we'll get really bad feedback on output
|
|
for (unsigned int i=0; i < numInputs; i++) {
|
|
LPWSTR itemName = NULL;
|
|
ppDevices->Item(i, &pDevice);
|
|
pDevice->GetId(&itemName);
|
|
// check the id of the endpoints to prevent adding in the default output device
|
|
if (defaultName && wcsicmp(itemName, defaultName)) {
|
|
pDevice->OpenPropertyStore(STGM_READ, &pProps);
|
|
pProps->GetValue(PKEY_Device_FriendlyName, &varName);
|
|
SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0,(LPARAM)varName.pwszVal);
|
|
SendDlgItemMessage(inWin, IDC_DEVBOX, CB_SETITEMDATA, i,(LPARAM)i);
|
|
}
|
|
CoTaskMemFree(itemName);
|
|
}
|
|
CoTaskMemFree(defaultName);
|
|
}
|
|
|
|
int count = SendDlgItemMessage(inWin, IDC_DEVBOX, CB_GETCOUNT, 0, 0);
|
|
if (!count) {
|
|
SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_NO_CAPTURE_DEVICES));
|
|
}
|
|
EnableWindowDlgItem(inWin, IDC_DEVBOX, count);
|
|
// reset to the first item in the list if there's any changes
|
|
if (!oldCount || count != oldCount) {
|
|
SendDlgItemMessage(inWin, IDC_DEVBOX, CB_SETCURSEL, 0, 0);
|
|
}
|
|
|
|
PropVariantClear(&varName);
|
|
SAFE_RELEASE(pProps)
|
|
SAFE_RELEASE(pEnumerate)
|
|
SAFE_RELEASE(pDevice)
|
|
SAFE_RELEASE(ppDevices)
|
|
CoUninitialize();
|
|
}
|
|
|
|
SendDlgItemMessage(inWin, IDC_DEVBOX, CB_SETCURSEL, Input_Device_ID, 0);
|
|
DisplayDeviceName();
|
|
return 1;
|
|
}
|
|
|
|
/*int getlev(int cs) {
|
|
HMIXER hmix;
|
|
int retval = -1;
|
|
#ifdef USE_VISTA_SOUND_FIX
|
|
HRESULT hr = S_OK;
|
|
IMMDeviceEnumerator *pEnumerator = NULL;
|
|
IMMDevice *pDevice = NULL;
|
|
IMMDeviceCollection *ppDevices = NULL;
|
|
hr = CoCreateGuid(&g_guidMyContext);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
// Get enumerator for audio endpoint devices.
|
|
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
|
hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
|
|
NULL, CLSCTX_INPROC_SERVER,
|
|
__uuidof(IMMDeviceEnumerator),
|
|
(void**)&pEnumerator);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = pEnumerator->EnumAudioEndpoints(eCapture,DEVICE_STATE_ACTIVE,&ppDevices);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
hr = ppDevices->Item(Input_Device_ID,&pDevice);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
//activate
|
|
hr = pDevice->Activate(__uuidof(IAudioEndpointVolume),
|
|
CLSCTX_ALL, NULL, (void**)&g_pEndptVol);
|
|
EXIT_ON_ERROR(hr)
|
|
//set mic volume
|
|
float fVolume =0.0;
|
|
hr = g_pEndptVol->GetMasterVolumeLevel(&fVolume);
|
|
EXIT_ON_ERROR(hr)
|
|
|
|
Exit:
|
|
if (FAILED(hr)) {
|
|
useXpSound = true;
|
|
} else {
|
|
retval = (int)fVolume * 100;
|
|
return retval;
|
|
}
|
|
|
|
SAFE_RELEASE(pEnumerator)
|
|
SAFE_RELEASE(pDevice)
|
|
SAFE_RELEASE(ppDevices)
|
|
SAFE_RELEASE(g_pEndptVol)
|
|
CoUninitialize();
|
|
|
|
#endif //USE_VISTA_SOUND_FIX
|
|
if (mixerOpen(&hmix, 0, 0, 0, 0) == MMSYSERR_NOERROR) {
|
|
MIXERLINE ml = {sizeof (ml), 0};
|
|
ml.dwComponentType = cs;
|
|
if (mixerGetLineInfo((HMIXEROBJ) hmix, &ml, MIXER_GETLINEINFOF_COMPONENTTYPE) == MMSYSERR_NOERROR) {
|
|
MIXERLINECONTROLS mlc = {sizeof (mlc), ml.dwLineID,};
|
|
MIXERCONTROL mc = {sizeof (mc),};
|
|
mlc.cControls = 1;
|
|
mlc.cbmxctrl = sizeof (mc);
|
|
mlc.pamxctrl = &mc;
|
|
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
|
|
if (mixerGetLineControls((HMIXEROBJ) hmix, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE) == MMSYSERR_NOERROR) {
|
|
MIXERCONTROLDETAILS mcd = {sizeof (mcd), mc.dwControlID, ml.cChannels,};
|
|
MIXERCONTROLDETAILS_UNSIGNED v[2];
|
|
mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED);
|
|
mcd.paDetails = v;
|
|
if (mixerGetControlDetails((HMIXEROBJ) hmix, &mcd, 0) == MMSYSERR_NOERROR) {
|
|
retval = (v[0].dwValue * 100) / (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum);
|
|
// retval = ((v[0].dwValue + v[1].dwValue) * 5) / (mc.Bounds.dwMaximum-mc.Bounds.dwMinimum);
|
|
}
|
|
}
|
|
}
|
|
mixerClose(hmix);
|
|
}
|
|
return retval;
|
|
}*/
|
|
|
|
void TitleCallback(int Connection, int Mode) {
|
|
MY_T_OUTPUT *Out = &Output[Connection];
|
|
// title update
|
|
if (Mode == 0) {
|
|
if (Out->AutoTitle == 1) {
|
|
// look at the playback queue so we can get the correct 'next song'
|
|
if (!WASABI_API_QUEUEMGR) {
|
|
// due to loading orders its possible the queue won't have been loaded on init so check
|
|
ServiceBuild(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
|
|
}
|
|
|
|
std::vector<std::wstring> nextList;
|
|
nextList.clear();
|
|
Encoder[Out->Encoder].UpdateTitle(0, nextList, Out->Handle, !!Out->NextTitles);
|
|
}
|
|
} else if (Mode == 1) {
|
|
// album art update
|
|
Encoder[Out->Encoder].UpdateAlbumArt(Out->Handle);
|
|
}
|
|
}
|
|
|
|
void CenterWindow(void) {
|
|
RECT rect, rectP;
|
|
int width, height;
|
|
int screenwidth, screenheight;
|
|
int x, y;
|
|
|
|
GetWindowRect(hMainDLG, &rect);
|
|
GetWindowRect(GetDesktopWindow(), &rectP);
|
|
|
|
width = rect.right - rect.left;
|
|
height = rect.bottom - rect.top;
|
|
|
|
x = ((rectP.right-rectP.left) - width) / 2 + rectP.left;
|
|
y = ((rectP.bottom-rectP.top) - height) / 2 + rectP.top;
|
|
|
|
screenwidth = GetSystemMetrics(SM_CXSCREEN);
|
|
screenheight = GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
if (x < 0) x = 0;
|
|
if (y < 0) y = 0;
|
|
if (x + width > screenwidth) x = screenwidth - width;
|
|
if (y + height > screenheight) y = screenheight - height;
|
|
|
|
mainrect.left = x;
|
|
mainrect.top = y;
|
|
}
|
|
|
|
int LoadConfig(void) {
|
|
lookAhead = GetPrivateProfileInt(APP_Name, "lookAhead", lookAhead, IniName);
|
|
skipMetada = !!GetPrivateProfileInt(APP_Name, "skipMetada", skipMetada, IniName);
|
|
lastFilterIndex = GetPrivateProfileInt(APP_Name, "ofnidx", lastFilterIndex, IniName);
|
|
|
|
curtab = GetPrivateProfileInt(APP_Name, "CurTab", curtab, IniName);
|
|
Connection_CurSelPos = GetPrivateProfileInt(APP_Name, "Connection_CurSelPos", Connection_CurSelPos, IniName);
|
|
curouttab = GetPrivateProfileInt(APP_Name, "Connection_CurTab", curouttab, IniName);
|
|
Encoder_CurSelPos = GetPrivateProfileInt(APP_Name, "Encoder_CurSelPos", Encoder_CurSelPos, IniName);
|
|
InputDevice = GetPrivateProfileInt(APP_Name, "InputDevice", InputDevice, IniName);
|
|
|
|
Input_CurSelPos = GetPrivateProfileInt(APP_Name, "Input_CurSelPos", Input_CurSelPos, IniName);
|
|
InputConfig.srate = LineInputAttribs[3].srate;
|
|
InputConfig.nch = LineInputAttribs[3].nch;
|
|
cf_mutex = CreateMutex(NULL, TRUE, NULL);
|
|
Crossfader = new C_CROSSFADER(CrossfadeLen,
|
|
LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].nch,
|
|
LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].srate);
|
|
|
|
MusVol = GetPrivateProfileInt(APP_Name, "MusicVolume", MusVol, IniName);
|
|
Mus2Vol = GetPrivateProfileInt(APP_Name, "BGMusicVolume", Mus2Vol, IniName);
|
|
MicVol = GetPrivateProfileInt(APP_Name, "MicVolume", MicVol, IniName);
|
|
|
|
// as we've changed the scaling then we will need to adjust from old to new
|
|
int tempFadeTime = GetPrivateProfileInt(APP_Name, "PTT_FadeTime", -1, IniName);
|
|
if (tempFadeTime == -1) {
|
|
FadeTime = GetPrivateProfileInt(APP_Name, "PTT_FT", FadeTime, IniName);
|
|
} else {
|
|
FadeTime = tempFadeTime * 5;
|
|
// remove the old instance of the settings
|
|
WritePrivateProfileString(APP_Name, "PTT_FadeTime", 0, IniName);
|
|
}
|
|
|
|
int tempMicFadeTime = GetPrivateProfileInt(APP_Name, "PTT_MicFadeTime", -1, IniName);
|
|
if (tempMicFadeTime == -1) {
|
|
MicFadeTime = GetPrivateProfileInt(APP_Name, "PTT_MicFT", MicFadeTime, IniName);
|
|
} else {
|
|
MicFadeTime = tempMicFadeTime * 5;
|
|
// remove the old instance of the settings
|
|
WritePrivateProfileString(APP_Name, "PTT_MicFadeTime", 0, IniName);
|
|
}
|
|
|
|
Restore_PTT = GetPrivateProfileInt(APP_Name, "PTT_Restore", 0, IniName);
|
|
Input_Device_ID = GetPrivateProfileInt(APP_Name, "PTT_MicInput",0, IniName);
|
|
|
|
// align to middle of screen on new installs
|
|
CenterWindow();
|
|
mainrect.left = GetPrivateProfileInt(APP_Name, "WindowLeft", mainrect.left, IniName);
|
|
mainrect.top = GetPrivateProfileInt(APP_Name, "WindowTop", mainrect.top, IniName);
|
|
|
|
GetPrivateProfileString(APP_Name, "Update", 0, updateStr, 16, IniName);
|
|
// no point in indicating a new version if we're now showing as ahead
|
|
if (!CompareVersions(updateStr)) {
|
|
WritePrivateProfileString(APP_Name, "Update", 0, IniName);
|
|
updateStr[0] = 0;
|
|
}
|
|
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
T_OUTPUT_CONFIG *Out = &Output[i].Config;
|
|
StringCchPrintfA(Out->Name, 32, "Output %u", i + 1);
|
|
StringCchPrintfW(Out->DisplayName, 32, WASABI_API_LNGSTRINGW(IDS_OUTPUT_X), i + 1);
|
|
Output[i].Encoder = -1;
|
|
Output[i].Handle = -1;
|
|
GetPrivateProfileString(Out->Name, "Address", "localhost", Out->Address, ARRAYSIZE(Out->Address), IniName);
|
|
GetPrivateProfileString(Out->Name, "UserID", "", Out->UserID, ARRAYSIZE(Out->UserID), IniName);
|
|
GetPrivateProfileString(Out->Name, "StreamID", "1", Out->StationID, ARRAYSIZE(Out->StationID), IniName);
|
|
Out->Port = GetPrivateProfileInt(Out->Name, "Port", 8000, IniName);
|
|
GetPrivateProfileString(Out->Name, "Password", "", Out->Password, ARRAYSIZE(Out->Password), IniName);
|
|
GetPrivateProfileString(Out->Name, "Cipherkey", "foobar", Out->cipherkey, ARRAYSIZE(Out->cipherkey), IniName);
|
|
GetPrivateProfileString(Out->Name, "Description", "Unnamed Server", Out->Description, ARRAYSIZE(Out->Description), IniName);
|
|
GetPrivateProfileString(Out->Name, "URL", "http://www.shoutcast.com", Out->ServerURL, ARRAYSIZE(Out->ServerURL), IniName);
|
|
GetPrivateProfileString(Out->Name, "Genre3", "Misc", Out->Genre, ARRAYSIZE(Out->Genre), IniName);
|
|
// check that the genre is a support value otherwise reset it to 'misc'
|
|
bool foundGenre = false;
|
|
for (int g = 0; g < ARRAYSIZE(genres); g++) {
|
|
if (!strcmpi(genres[g].name, Out->Genre)) {
|
|
foundGenre = true;
|
|
break;
|
|
}
|
|
}
|
|
if (foundGenre == false) {
|
|
lstrcpyn(Out->Genre, "Misc", ARRAYSIZE(Out->Genre));
|
|
}
|
|
|
|
GetPrivateProfileString(Out->Name, "AIM", "N/A", Out->AIM, ARRAYSIZE(Out->AIM), IniName);
|
|
GetPrivateProfileString(Out->Name, "ICQ", "0", Out->ICQ, ARRAYSIZE(Out->ICQ), IniName);
|
|
GetPrivateProfileString(Out->Name, "IRC", "N/A", Out->IRC, ARRAYSIZE(Out->IRC), IniName);
|
|
Out->Public = GetPrivateProfileInt(Out->Name, "Public", 1, IniName);
|
|
Out->AutoRecon = GetPrivateProfileInt(Out->Name, "AutoRecon", 1, IniName);
|
|
Out->ReconTime = GetPrivateProfileInt(Out->Name, "ReconTime", 5, IniName);
|
|
if (Out->ReconTime < 1) {
|
|
Out->ReconTime = 5;
|
|
}
|
|
Out->doTitleUpdate = GetPrivateProfileInt(Out->Name, "doTitleUpdate", 1, IniName);
|
|
GetPrivateProfileString(Out->Name, "now", "", Out->Now, ARRAYSIZE(Out->Now), IniName);
|
|
GetPrivateProfileString(Out->Name, "next", "", Out->Next, ARRAYSIZE(Out->Next), IniName);
|
|
Output[i].AutoTitle = GetPrivateProfileInt(Out->Name, "AutoTitle", 1, IniName);
|
|
Output[i].AutoConnect = GetPrivateProfileInt(Out->Name, "AutoConnect", 0, IniName);
|
|
Output[i].Logging = GetPrivateProfileInt(Out->Name, "Logging", 0, IniName);
|
|
Output[i].LogCOS = GetPrivateProfileInt(Out->Name, "LogCOS", 0, IniName);
|
|
Output[i].NextTitles = GetPrivateProfileInt(Out->Name, "NextTitles", 1, IniName);
|
|
Output[i].Config.protocol = GetPrivateProfileInt(Out->Name, "protocol", -1, IniName);
|
|
if (Output[i].Config.protocol == -1) {
|
|
Output[i].Config.protocol = MAKEWORD(2, 1);
|
|
}
|
|
// check the v1 password for : and split it if the dj/user id is empty (i.e. post 2.2.3 import)
|
|
if (LOBYTE(Output[i].Config.protocol) == 1 && Out->Password[0] && !Out->UserID[0]) {
|
|
char* password = strstr(Out->Password, ":");
|
|
if (password) {
|
|
*password = 0;
|
|
lstrcpyn(Out->UserID, Out->Password, ARRAYSIZE(Out->UserID));
|
|
lstrcpyn(Out->Password, ++password, ARRAYSIZE(Out->Password));
|
|
}
|
|
}
|
|
Output[i].nextTrackLog = GetPrivateProfileInt(Out->Name, "nextTrackLog", 0, IniName);
|
|
Output[i].nextTrackLogXML = GetPrivateProfileInt(Out->Name, "nextTrackLogXML", 0, IniName);
|
|
if (!GetPrivateProfileStringUTF8(Out->Name, "nextTrackPath", 0, Output[i].nextTrackPath, ARRAYSIZE(Output[i].nextTrackPath), IniName)) {
|
|
GetDefaultNextTracksLogFile(module.hwndParent, ARRAYSIZE(Output[i].nextTrackPath), Output[i].nextTrackPath, i);
|
|
}
|
|
|
|
Output[i].useArt = GetPrivateProfileInt(Out->Name, "useArt", 0, IniName);
|
|
Output[i].usePlayingArt = GetPrivateProfileInt(Out->Name, "usePlayingArt", 0, IniName);
|
|
Output[i].useStreamArt = GetPrivateProfileInt(Out->Name, "useStreamArt", 1, IniName);
|
|
GetPrivateProfileStringUTF8(Out->Name, "stationArtPath", 0, Output[i].stationArtPath, ARRAYSIZE(Output[i].stationArtPath), IniName);
|
|
|
|
Output[i].saveEncoded = GetPrivateProfileInt(Out->Name, "saveEncoded", 0, IniName);
|
|
GetPrivateProfileStringUTF8(Out->Name, "saveEncodedPath", 0, Output[i].saveEncodedPath, ARRAYSIZE(Output[i].saveEncodedPath), IniName);
|
|
|
|
Output[i].Encoder = GetPrivateProfileInt(Out->Name, "Encoder", i == 0 ? 0 : -1, IniName);
|
|
if (Output[i].Encoder != -1) {
|
|
if (WaitForSingleObject(Enc_mutex[Output[i].Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Output[i].Handle = Encoder[Output[i].Encoder].AddOutput(i, Out, TitleCallback);
|
|
ReleaseMutex(Enc_mutex[Output[i].Encoder]);
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
wchar_t* BuildLameVersion(void) {
|
|
static wchar_t version[128] = {0};
|
|
if (libinst != NULL && !version[0]) {
|
|
BE_VERSION ver;
|
|
beVersion(&ver);
|
|
|
|
if (ver.byBetaLevel) {
|
|
StringCchPrintfW(version, ARRAYSIZE(version), L"%u.%ub%u", (unsigned int)ver.byMajorVersion, (unsigned int)ver.byMinorVersion, (unsigned int)ver.byBetaLevel);
|
|
} else if (ver.byAlphaLevel) {
|
|
StringCchPrintfW(version, ARRAYSIZE(version), L"%u.%ua%u", (unsigned int)ver.byMajorVersion, (unsigned int)ver.byMinorVersion, (unsigned int)ver.byAlphaLevel);
|
|
} else {
|
|
StringCchPrintfW(version, ARRAYSIZE(version), L"%u.%u", (unsigned int)ver.byMajorVersion, (unsigned int)ver.byMinorVersion);
|
|
}
|
|
}
|
|
return version;
|
|
}
|
|
|
|
void LoadEncoders() {
|
|
/* load lame_enc.dll */
|
|
wchar_t dllname[MAX_PATH] = {0};
|
|
StringCchPrintfW(dllname, ARRAYSIZE(dllname), L"%s\\lame_enc.dll", GetSharedDirectoryW(module.hwndParent));
|
|
|
|
libinst = LoadLibraryW(dllname);
|
|
if (libinst == NULL) {
|
|
wchar_t title[128] = {0}, message[512] = {0};
|
|
StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_VersionW);
|
|
StringCchPrintfW(message, ARRAYSIZE(message), LocalisedString(IDS_FAILED_LOAD_LAMEDLL, NULL, 0), GetSharedDirectoryW(module.hwndParent));
|
|
MessageBoxW(module.hwndParent, message, title, MB_ICONWARNING);
|
|
} else {
|
|
beVersion = (BEVERSION) GetProcAddress(libinst, "beVersion");
|
|
init = (void *) GetProcAddress(libinst, "lame_init");
|
|
params = (void *) GetProcAddress(libinst, "lame_init_params");
|
|
encode = (void *) GetProcAddress(libinst, "lame_encode_buffer_interleaved");
|
|
finish = (void *) GetProcAddress(libinst, "lame_encode_flush");
|
|
|
|
if (!init || !params || !encode || !finish) {
|
|
wchar_t title[128] = {0};
|
|
StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_VersionW);
|
|
MessageBoxW(module.hwndParent, LocalisedString(IDS_LAMEDLL_ISSUE, NULL, 0), title, MB_ICONWARNING);
|
|
FreeLibrary(libinst);
|
|
libinst = 0;
|
|
}
|
|
}
|
|
|
|
/* load encoder type */
|
|
for (int i = 0; i < NUM_ENCODERS; i++) {
|
|
char name[32] = {0};
|
|
Enc_mutex[i] = CreateMutex(NULL, TRUE, NULL);
|
|
StringCchPrintfA(name, ARRAYSIZE(name), "Encoder %u", i + 1);
|
|
int EncType = GetPrivateProfileInt(name, "Type", 2, IniName);
|
|
// store our type for later on
|
|
Enc_LastType[i] = EncType;
|
|
switch (EncType) {
|
|
/* mp3 */
|
|
case 1:
|
|
{
|
|
fallback:
|
|
Encoder[i].SetLame(init, params, encode, finish);
|
|
Encoder[i].SetEncoder(DEFAULT_ENCODER);
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
|
|
T_ENCODER_MP3_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_MP3_INFO *encset = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
EncSettings.output_bitRate = GetPrivateProfileInt(name, "BitRate", EncSettings.output_bitRate, IniName);
|
|
EncSettings.output_sampleRate = GetPrivateProfileInt(name, "SampleRate", EncSettings.output_sampleRate, IniName);
|
|
EncSettings.output_numChannels = GetPrivateProfileInt(name, "NumChannels", EncSettings.output_numChannels, IniName);
|
|
EncSettings.QualityMode = GetPrivateProfileInt(name, "QualityMode", 8, IniName);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
// map any AAC LC from the prior versions to FHG AAC with 5.62+
|
|
case 3:
|
|
{ // FHG AAC
|
|
if (C_ENCODER_FHGAAC::isPresent(module.hwndParent)) {
|
|
Encoder[i].SetEncoder(new C_ENCODER_FHGAAC(module.hwndParent), 1);
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
T_ENCODER_FHGAAC_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_FHGAAC_INFO *encset = (T_ENCODER_FHGAAC_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
((C_ENCODER_NSV*) Enc)->ReadConfFile(IniName, name);
|
|
}
|
|
} else if (C_ENCODER_AACP::isPresent(module.hwndParent)) { // AAC+
|
|
Encoder[i].SetEncoder(new C_ENCODER_AACP(module.hwndParent), 1);
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
T_ENCODER_AACP_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_AACP_INFO *encset = (T_ENCODER_AACP_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
((C_ENCODER_NSV*) Enc)->ReadConfFile(IniName, name);
|
|
}
|
|
} else {
|
|
//Encoder[i].SetEncoder(NULL);
|
|
// attempt to get to a valid encoder if the aac one disappeared
|
|
goto fallback;
|
|
}
|
|
}
|
|
break;
|
|
#ifdef USE_OGG
|
|
case 4:
|
|
{ // OGG
|
|
if (C_ENCODER_OGG::isPresent(module.hwndParent)) {
|
|
Encoder[i].SetEncoder(new C_ENCODER_OGG(module.hwndParent), 1);
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
T_ENCODER_OGG_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_OGG_INFO *encset = (T_ENCODER_OGG_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
((C_ENCODER_NSV*) Enc)->ReadConfFile(IniName, name);
|
|
}
|
|
} else Encoder[i].SetEncoder(NULL);
|
|
}
|
|
break;
|
|
#endif // USE_OGG
|
|
default:
|
|
{
|
|
Encoder[i].SetEncoder(NULL);
|
|
}
|
|
break;
|
|
}
|
|
ReleaseMutex(Enc_mutex[i]);
|
|
}
|
|
}
|
|
|
|
void SetEncoderPanelMode(HWND hDlg, C_ENCODER * Enc) {
|
|
BOOL show = (Enc != NULL);
|
|
if (show) {
|
|
if (Enc->UseNsvConfig() == true) {
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS, SW_HIDE);
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON, SW_SHOW);
|
|
wchar_t tmp[128] = {0};
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_CURRENT_BITRATE, NULL, 0), ((T_EncoderIOVals*) Enc->GetExtInfo())->output_bitRate);
|
|
SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LABEL, tmp);
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_LAME_VER, SW_HIDE);
|
|
} else {
|
|
wchar_t *lame_version = BuildLameVersion();
|
|
if (lame_version && *lame_version)
|
|
{
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS, SW_SHOW);
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON, SW_HIDE);
|
|
SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LABEL, LocalisedString(IDS_ENCODER_SETTINGS, NULL, 0));
|
|
|
|
wchar_t tmp[128] = {0};
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_LAME_ENCODER_VER, NULL, 0), lame_version);
|
|
SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LAME_VER, tmp);
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_LAME_VER, SW_SHOW);
|
|
} else {
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS, SW_HIDE);
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON, SW_HIDE);
|
|
SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LABEL, LocalisedString(IDS_MP3_ENCODING_NOT_AVAILABLE, NULL, 0));
|
|
}
|
|
}
|
|
} else {
|
|
ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_LAME_VER, SW_HIDE);
|
|
}
|
|
|
|
// show / hide the groupbox around the main encoder options
|
|
// which is setup to make it look like it's only around the
|
|
// options available depending upon the mode that is in use
|
|
ShowWindowDlgItem(hDlg, IDC_INFO_FRAME4, !show);
|
|
ShowWindowDlgItem(hDlg, IDC_INFO_FRAME5, show);
|
|
|
|
// show / hide the save encoded audio options as applicable
|
|
ShowWindowDlgItem(hDlg, IDC_INFO_FRAME3, show);
|
|
ShowWindowDlgItem(hDlg, IDC_SAVE_ENCODED_AUDIO, show);
|
|
ShowWindowDlgItem(hDlg, IDC_SAVE_ENCODED_AUDIO_EDIT, show);
|
|
ShowWindowDlgItem(hDlg, IDC_SAVE_ENCODED_AUDIO_BROWSE, show);
|
|
}
|
|
|
|
void FreeStreamAlbumArt(int Index) {
|
|
if (streamImage[Index] > (ARGB32 *)0 &&
|
|
streamImage[Index] != (ARGB32 *)-1 &&
|
|
WASABI_API_MEMMGR) {
|
|
WASABI_API_MEMMGR->sysFree(streamImage[Index]);
|
|
streamImage[Index] = (ARGB32 *)-1;
|
|
}
|
|
streamLength[Index] = 0;
|
|
}
|
|
|
|
// destroy dlg and exit
|
|
int doQuit(void) {
|
|
if (nowPlayingHook) {
|
|
UnhookWindowsHookEx(nowPlayingHook);
|
|
nowPlayingHook = 0;
|
|
}
|
|
if (nowPlayingHook2) {
|
|
UnhookWindowsHookEx(nowPlayingHook2);
|
|
nowPlayingHook2 = 0;
|
|
}
|
|
|
|
RemoveSystrayIcon(hMainDLG, SYSTRAY_ICY_ICON);
|
|
|
|
GetWindowRect(hMainDLG, &mainrect);
|
|
|
|
KillTimer(hMainDLG, wnd[curtab].id);
|
|
KillTimer(hMainDLG, IDD_ENCODER);
|
|
KillTimer(hMainDLG, 666);
|
|
KillTimer(hMainDLG, 1234);
|
|
KillTimer(hMainDLG, 1337);
|
|
KillTimer(hMainDLG, 2234);
|
|
KillTimer(hMainDLG, 2235);
|
|
if (curtab == 1) KillTimer(wnd[curtab].hWnd, out_wnd[curouttab].id);
|
|
if (curtab == 2) KillTimer(wnd[curtab].hWnd, in_wnd[InputDevice].id);
|
|
ini_modified = 1;
|
|
/* Disconnect all outputs */
|
|
int done;
|
|
do {
|
|
done = 1;
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
MY_T_OUTPUT *Out = &Output[i];
|
|
if (Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
int state = Enc->GetState(Out->Handle);
|
|
if (state != OUT_DISCONNECTED && state != OUT_ERROR) {
|
|
done = 0;
|
|
Enc->DisconnectOutput(Out->Handle);
|
|
} else {
|
|
// shutdown the logging options
|
|
if (Out->Logging) {
|
|
StopLogging(i);
|
|
}
|
|
if (Out->nextTrackLog) {
|
|
StopNextTracks(i);
|
|
}
|
|
if (Out->saveEncoded) {
|
|
StopSaveEncoded(i);
|
|
}
|
|
}
|
|
Enc->Run(OM_OUTPUT | OM_OTHER);
|
|
}
|
|
}
|
|
Sleep(200);
|
|
} while (!done);
|
|
|
|
// reset levels if PTT is enabled when we are closing
|
|
if (FadeOut && InputDevice) {
|
|
int micsrc = Input_Device_ID >= 1 ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
|
|
setlev(micsrc, 0);
|
|
setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, MusVol * 10);
|
|
}
|
|
|
|
if (hthread) {
|
|
CloseHandle(hthread);
|
|
hthread = NULL;
|
|
}
|
|
|
|
if (hthreadout) {
|
|
CloseHandle(hthreadout);
|
|
hthreadout = NULL;
|
|
}
|
|
|
|
ReleaseMutex(cf_mutex);
|
|
Soundcard.Close();
|
|
|
|
SendMessage(hMainDLG, WM_TIMER, MAKEWPARAM(666,0), 0); // force an INI save
|
|
|
|
if (playingImage && WASABI_API_MEMMGR) {
|
|
WASABI_API_MEMMGR->sysFree(playingImage);
|
|
playingImage = 0;
|
|
}
|
|
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
FreeStreamAlbumArt(i);
|
|
}
|
|
|
|
if (libinst) {
|
|
FreeLibrary(libinst);
|
|
libinst = 0;
|
|
}
|
|
C_ENCODER_FHGAAC::Unload();
|
|
C_ENCODER_AACP::Unload();
|
|
#ifdef USE_OGG
|
|
C_ENCODER_OGG::Unload();
|
|
#endif // USE_OGG
|
|
|
|
for (int i = 0; i < num_tabwnds; i++) DestroyWindow(wnd[i].hWnd);
|
|
for (int i = 0; i < num_inwnds; i++) DestroyWindow(in_wnd[i].hWnd);
|
|
for (int i = 0; i < num_outwnds; i++) DestroyWindow(out_wnd[i].hWnd);
|
|
|
|
for (int ii = 0; ii < NUM_OUTPUTS; ii++) {
|
|
MY_T_OUTPUT *Out = &Output[ii];
|
|
// removed encoder selection
|
|
if (Out->Encoder != -1) {
|
|
if (Out->Handle != -1) {
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[Out->Encoder].RemoveOutput(Out->Handle);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DestroyWindow(hMainDLG);
|
|
hMainDLG = NULL;
|
|
|
|
num_cols = num_outwnds = num_inwnds = num_tabwnds = 0;
|
|
memset(&col, 0, sizeof(col));
|
|
memset(&wnd, 0, sizeof(wnd));
|
|
memset(&out_wnd, 0, sizeof(out_wnd));
|
|
memset(&in_wnd, 0, sizeof(in_wnd));
|
|
memset(&Output, 0, sizeof(Output));
|
|
WASABI_API_LNG_HINST = WASABI_API_ORIG_HINST = 0;
|
|
|
|
memset(&lastFile, 0, sizeof(lastFile));
|
|
memset(&lastSec, 0, sizeof(lastSec));
|
|
memset(&lastFile, 0, sizeof(lastFile));
|
|
memset(&lastMode, -1, sizeof(lastMode));
|
|
memset(&lastEnable, 0, sizeof(lastEnable));
|
|
memset(&buttonWnd, 0, sizeof(buttonWnd));
|
|
memset(&tabWnd, 0, sizeof(tabWnd));
|
|
memset(&outTabWnd, 0, sizeof(outTabWnd));
|
|
memset(&streamLength, 0, sizeof(streamLength));
|
|
memset(&secChanged, 0, sizeof(secChanged));
|
|
|
|
playingImage_w = playingImage_h = playingLength = playingType;
|
|
|
|
if (boldFont) {
|
|
DeleteObject(boldFont);
|
|
boldFont = NULL;
|
|
}
|
|
normalFont = NULL;
|
|
|
|
ServiceRelease(WASABI_API_SVC, AGAVE_API_CONFIG, AgaveConfigGUID);
|
|
ServiceRelease(WASABI_API_SVC, WASABI_API_LNG, languageApiGUID);
|
|
ServiceRelease(WASABI_API_SVC, WASABI_API_MEMMGR, memMgrApiServiceGuid);
|
|
ServiceRelease(WASABI_API_SVC, AGAVE_API_ALBUMART, albumArtGUID);
|
|
ServiceRelease(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
|
|
ServiceRelease(WASABI_API_SVC, WASABI_API_EXPLORERFINDFILE,ExplorerFindFileApiGUID);
|
|
ServiceRelease(WASABI_API_SVC, WAC_API_DOWNLOADMANAGER, DownloadManagerGUID);
|
|
WASABI_API_SVC = NULL;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void SetBoldDialogItemFont(HWND hwndControl) {
|
|
if (!boldFont) {
|
|
HFONT hFont = (HFONT)SendMessageW(hMainDLG, WM_GETFONT, 0, 0);
|
|
LOGFONTW lf = {0};
|
|
GetObjectW(hFont, sizeof(LOGFONTW), &lf);
|
|
lf.lfWeight = FW_BOLD;
|
|
boldFont = CreateFontIndirectW(&lf);
|
|
}
|
|
if (boldFont) {
|
|
SendMessageW(hwndControl, WM_SETFONT, (WPARAM)boldFont, MAKELPARAM(1,0));
|
|
}
|
|
}
|
|
|
|
LRESULT WINAPI headerProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
if (uMsg == WM_SETCURSOR) {
|
|
return TRUE;
|
|
}
|
|
return CallWindowProcW(prevHeaderProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
LRESULT WINAPI listViewProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
switch (uMsg) {
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_STREAM_1:
|
|
case IDC_STREAM_2:
|
|
case IDC_STREAM_3:
|
|
case IDC_STREAM_4:
|
|
case IDC_STREAM_5:
|
|
{
|
|
int oldCurSelPos = Connection_CurSelPos;
|
|
Connection_CurSelPos = (LOWORD(wParam) - IDC_STREAM_1);
|
|
ListView_SetItemState(hWnd, Connection_CurSelPos, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
|
|
SetFocus(hWnd);
|
|
SendMessage(wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_CONNECT, BN_CLICKED), (LPARAM)GetDlgItem(wnd[1].hWnd, IDC_CONNECT));
|
|
Connection_CurSelPos = oldCurSelPos;
|
|
}
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
if(((LPNMHDR)lParam)->code == HDN_BEGINTRACKW ||
|
|
((LPNMHDR)lParam)->code == HDN_ITEMCHANGINGW) {
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return CallWindowProcW(prevListViewProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
void SetTabErrorText(HWND hwnd, int index, int current, LPRECT r, bool update = false) {
|
|
HDC hDC = GetDC(hwnd);
|
|
if (!normalFont) {
|
|
normalFont = (HFONT)SendMessageW(hMainDLG, WM_GETFONT, 0, 0);
|
|
}
|
|
HFONT hOldFont = (HFONT)SelectObject(hDC, normalFont);
|
|
int oldTextColor = SetTextColor(hDC, (!update ? RGB(255,0,0) : RGB(0,0,255)));
|
|
int oldBkMode = SetBkMode(hDC, TRANSPARENT);
|
|
|
|
wchar_t buf[128] = {0};
|
|
TCITEMW pitem = {0};
|
|
pitem.mask = TCIF_TEXT;
|
|
pitem.pszText = buf;
|
|
pitem.cchTextMax = ARRAYSIZE(buf);
|
|
SendMessageW(hwnd, TCM_GETITEMW, index, (LPARAM)&pitem);
|
|
|
|
r->top += (current ? 1 : 3);
|
|
r->left += 6;
|
|
|
|
// if themeing is enabled then we need to paint the background to avoid the font going weird / double-bold like
|
|
// and to ensure we're correct, am taking a 1px sliver and stretching it across the area before drawing the text
|
|
if (isthemethere) {
|
|
StretchBlt(hDC, r->left, r->top + 1, r->right - r->left - 3, r->bottom - r->top - 3, hDC, r->left - 4, r->top + 1, 1, r->bottom - r->top - 3, SRCCOPY);
|
|
}
|
|
|
|
DrawTextW(hDC, pitem.pszText, wcslen(pitem.pszText), r, DT_SINGLELINE);
|
|
SetTextColor(hDC, oldTextColor);
|
|
SetBkMode(hDC, oldBkMode);
|
|
SelectObject(hDC, hOldFont);
|
|
ReleaseDC(hwnd, hDC);
|
|
}
|
|
|
|
LRESULT WINAPI tabWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
LRESULT ret = CallWindowProcW(prevTabWndProc, hWnd, uMsg, wParam, lParam);
|
|
if (uMsg == WM_PAINT) {
|
|
RECT r = {0};
|
|
int item = ListView_GetNextItem(GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS), -1, LVNI_SELECTED);
|
|
if ((curtab == 1 ?
|
|
(lastMode[Connection_CurSelPos] >= 3 && lastMode[Connection_CurSelPos] <= 6) :
|
|
(lastMode[item] >= 3 && lastMode[item] <= 6)
|
|
) && TabCtrl_GetItemRect(hWnd, 1, &r)) {
|
|
SetTabErrorText(hWnd, 1, (curtab == 1), &r);
|
|
}
|
|
|
|
// show the update flag on things!
|
|
if (updateStr && updateStr[0]) {
|
|
RECT r = {0};
|
|
TabCtrl_GetItemRect(tabWnd, 3, &r);
|
|
SetTabErrorText(tabWnd, 3, (curtab == 3), &r, TRUE);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LRESULT WINAPI outTabWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
LRESULT ret = CallWindowProcW(prevOutTabWndProc, hWnd, uMsg, wParam, lParam);
|
|
if (uMsg == WM_PAINT) {
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
RECT r = {0};
|
|
int index[] = {0, 0, 1, 2};
|
|
if ((lastMode[i] >= 3 && lastMode[i] <= 6) && (i == Connection_CurSelPos) && TabCtrl_GetItemRect(hWnd, index[(lastMode[i] - 3)], &r)) {
|
|
SetTabErrorText(hWnd, index[(lastMode[i] - 3)], (curouttab == index[(lastMode[i] - 3)]), &r);
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LRESULT WINAPI buttonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
int ret;
|
|
switch (uMsg) {
|
|
case WM_LBUTTONDOWN:
|
|
ret = CallWindowProcW(prevButtonProc, hWnd, uMsg, wParam, lParam);
|
|
if (SendDlgItemMessage(GetParent(hWnd), IDC_LOCK, BM_GETSTATE, 0, 0) != BST_CHECKED) {
|
|
blockmousemove = 1;
|
|
KillTimer(hMainDLG, 2234);
|
|
KillTimer(hMainDLG, 2235);
|
|
if ((MicFadeStartTime != 0 || FadeStartTime != 0) && FadeOut != 1) {
|
|
clock_t myTime = clock();
|
|
if (FadeStartTime != 0) FadeStartTime = myTime - ((FadeTime * 100)-(myTime - FadeStartTime));
|
|
if (MicFadeStartTime != 0) MicFadeStartTime = myTime - ((MicFadeTime * 100)-(myTime - MicFadeStartTime));
|
|
}
|
|
FadeOut = 1;
|
|
SetTimer(hMainDLG, 2234, 10, NULL); // fade out
|
|
SetTimer(hMainDLG, 2235, 10, NULL); // fade out
|
|
//if (FadeOut) do_capture();
|
|
#ifdef CAPTURE_TESTING
|
|
if (FadeOut) {
|
|
if (!pPlayer) {
|
|
pPlayer = new Player(hMainDLG);
|
|
}
|
|
if (!pCallbacks) {
|
|
pCallbacks = new CPlayerCallbacks();
|
|
}
|
|
pPlayer->SetPlayerCallbacks(pCallbacks);
|
|
pPlayer->RefreshDeviceList(eRender);
|
|
pPlayer->RefreshDeviceList(eCapture);
|
|
pPlayer->SelectDefaultDevice(eRender, eConsole);
|
|
pPlayer->SelectDefaultDevice(eCapture, eConsole);
|
|
pPlayer->SelectDeviceFromList(eCapture, 0);
|
|
//pPlayer->SelectDeviceFromList(eRender, 2);
|
|
if (pPlayer->Play(eCaptureEndpoint) == FALSE) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
#endif
|
|
} else {
|
|
SendMessage(hWnd, BM_SETSTATE, TRUE, 0);
|
|
ret = 0;
|
|
}
|
|
return ret;
|
|
|
|
case WM_MOUSEMOVE:
|
|
if (blockmousemove) return 0;
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
ret = CallWindowProcW(prevButtonProc, hWnd, uMsg, wParam, lParam);
|
|
if (SendDlgItemMessage(GetParent(hWnd), IDC_LOCK, BM_GETSTATE, 0, 0) != BST_CHECKED) {
|
|
blockmousemove = 0;
|
|
KillTimer(hMainDLG, 2234);
|
|
KillTimer(hMainDLG, 2235);
|
|
if ((MicFadeStartTime != 0 || FadeStartTime != 0) && FadeOut != 0) {
|
|
clock_t myTime = clock();
|
|
if (FadeStartTime != 0) FadeStartTime = myTime - ((FadeTime * 100)-(myTime - FadeStartTime));
|
|
if (MicFadeStartTime != 0) MicFadeStartTime = myTime - ((MicFadeTime * 100)-(myTime - MicFadeStartTime));
|
|
}
|
|
FadeOut = 0;
|
|
SetTimer(hMainDLG, 2234, 10, NULL); // fade in
|
|
SetTimer(hMainDLG, 2235, 10, NULL); // fade in
|
|
} else {
|
|
SendMessage(hWnd, BM_SETSTATE, TRUE, 0);
|
|
ret = 0;
|
|
}
|
|
return ret;
|
|
}
|
|
return CallWindowProcW(prevButtonProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
int CALLBACK EncFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
switch (uMsg) {
|
|
case WM_INITDIALOG:
|
|
{
|
|
// doing this to get the button + combobox to appear as the same size when scrolling through them all
|
|
RECT r;
|
|
GetClientRect(GetDlgItem(hDlg, IDC_ENCSETTINGS), &r);
|
|
MapWindowPoints(GetDlgItem(hDlg, IDC_ENCSETTINGS), hDlg, (LPPOINT)&r,2);
|
|
InflateRect(&r, 1, 1);
|
|
SetWindowPos(GetDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON), 0, r.left, r.top, r.right-r.left, r.bottom-r.top, SWP_NOZORDER|SWP_NOACTIVATE);
|
|
}
|
|
break;
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_ENCODERLIST:
|
|
{
|
|
if (HIWORD(wParam) == LBN_SELCHANGE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Encoder_CurSelPos = Out->Encoder;
|
|
|
|
if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
HWND e = hDlg;
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_RESETCONTENT, 0, 0);
|
|
int item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_NONE, NULL, 0));
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"None");
|
|
|
|
item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_MP3_ENCODER, NULL, 0));
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"MP3 Encoder");
|
|
|
|
if (C_ENCODER_FHGAAC::isPresent(module.hwndParent)) {
|
|
item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_FHGAAC_ENCODER, NULL, 0));
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"Fraunhofer Encoder");
|
|
} else if (C_ENCODER_AACP::isPresent(module.hwndParent)) {
|
|
item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_AACP_ENCODER, NULL, 0));
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"AAC+ Encoder");
|
|
}
|
|
#ifdef USE_OGG
|
|
if (C_ENCODER_OGG::isPresent(module.hwndParent)) {
|
|
// TODO
|
|
item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) L"OGG Vorbis Encoder"/*LocalisedString(IDS_OGG_ENCODER, NULL, 0)*/);
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"OGG Vorbis Encoder");
|
|
}
|
|
#endif // USE_OGG
|
|
|
|
SendDlgItemMessage(e, IDC_ENCSETTINGS, CB_RESETCONTENT, 0, 0);
|
|
SetEncoderPanelMode(e, Enc);
|
|
|
|
int attribnum = 0, typeval = 0;
|
|
if (Enc) {
|
|
int i;
|
|
for (int i = 0; i < NUM_ENCODERS; i++) {
|
|
char* encoder = (char*)SendDlgItemMessage(e, IDC_ENCTYPE, CB_GETITEMDATA, i, 0);
|
|
if (!strcmp(Enc->GetName(), encoder)) {
|
|
typeval = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int infosize = sizeof (T_EncoderIOVals);
|
|
T_ENCODER_MP3_INFO *EncInfo = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
|
|
for (i = Enc->GetNumAttribs() - 1; i >= 0; i--) {
|
|
T_ATTRIB attrib;
|
|
Enc->EnumAttrib(i, &attrib);
|
|
SendDlgItemMessage(e, IDC_ENCSETTINGS, CB_INSERTSTRING, 0, (LPARAM) attrib.Text);
|
|
T_ENCODER_MP3_INFO *OutVal = (T_ENCODER_MP3_INFO *) attrib.OutputVals;
|
|
if (OutVal && EncInfo && infosize) {
|
|
T_ENCODER_MP3_INFO *EncSettings = (T_ENCODER_MP3_INFO *) EncInfo;
|
|
if(OutVal->output_bitRate == EncSettings->output_bitRate &&
|
|
OutVal->output_sampleRate == EncSettings->output_sampleRate &&
|
|
OutVal->output_numChannels == EncSettings->output_numChannels) {
|
|
attribnum = i;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
SendDlgItemMessageW(e, IDC_ENCSETTINGS, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_NONE, NULL, 0));
|
|
ShowWindowDlgItem(e, IDC_ENCSETTINGS, SW_HIDE);
|
|
ShowWindowDlgItem(e, IDC_ENCSETTINGS_BUTTON, SW_HIDE);
|
|
SetDlgItemTextW(e, IDC_ENCSETTINGS_LABEL, LocalisedString(IDS_NO_ENCODER_SELECTED, NULL, 0));
|
|
}
|
|
|
|
SendDlgItemMessage(e, IDC_ENCSETTINGS, CB_SETCURSEL, attribnum, 0);
|
|
SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETCURSEL, typeval, 0);
|
|
ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
|
|
ini_modified = 1;
|
|
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_ENCSETTINGS, CBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_ENCSETTINGS));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_ENCTYPE:
|
|
{
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
int typenum = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
|
|
|
|
// check to see if this is the same encoder as last time as
|
|
// there's no need to update it if there hasn't been a change
|
|
// so selecting the same encoder won't cause a settings reset
|
|
if (typenum && typenum == Enc_LastType[Encoder_CurSelPos]) break;
|
|
else Enc_LastType[Encoder_CurSelPos] = typenum;
|
|
|
|
char* typestr = (char*)SendMessage((HWND) lParam, CB_GETITEMDATA, typenum, 0);
|
|
if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
|
|
if (!strcmpi("MP3 Encoder", typestr)) {
|
|
//lame setup
|
|
Encoder[Encoder_CurSelPos].SetLame(init, params, encode, finish);
|
|
Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_MP3(init, params, encode, finish), 1);
|
|
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
|
|
if (Enc) {
|
|
if (strcmpi(Enc->GetName(), "MP3 Encoder") == 0) {
|
|
T_ENCODER_MP3_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_MP3_INFO *encset = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize)
|
|
memcpy(&EncSettings, encset, infosize);
|
|
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
EncSettings.output_bitRate = MP3_DEFAULT_OUTPUTBITRATE;
|
|
EncSettings.output_sampleRate = MP3_DEFAULT_OUTPUTSAMPLERATE;
|
|
EncSettings.output_numChannels = MP3_DEFAULT_OUTPUTNUMCHANNELS;
|
|
Enc->ChangeSettings(&EncSettings);
|
|
}
|
|
}
|
|
} else if (!strcmpi("Fraunhofer Encoder", typestr)) { // FHG AAC
|
|
Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_FHGAAC(module.hwndParent), 1);
|
|
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
if (Enc) {
|
|
T_ENCODER_FHGAAC_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_FHGAAC_INFO *encset = (T_ENCODER_FHGAAC_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
}
|
|
} else if (!strcmpi("AAC+ Encoder", typestr)) { //AAC+
|
|
Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_AACP(module.hwndParent), 1);
|
|
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
if (Enc) {
|
|
T_ENCODER_AACP_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_AACP_INFO *encset = (T_ENCODER_AACP_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
}
|
|
}
|
|
#ifdef USE_OGG
|
|
else if (!strcmpi("OGG Vorbis Encoder", typestr)) { //OGG
|
|
Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_OGG(module.hwndParent), 1);
|
|
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
if (Enc) {
|
|
T_ENCODER_OGG_INFO EncSettings;
|
|
int infosize = sizeof (EncSettings);
|
|
T_ENCODER_OGG_INFO *encset = (T_ENCODER_OGG_INFO *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) memcpy(&EncSettings, encset, infosize);
|
|
EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
Enc->ChangeSettings(&EncSettings);
|
|
}
|
|
}
|
|
#endif // USE_OGG
|
|
else {
|
|
int i;
|
|
for (i = 0; i < NUM_OUTPUTS; i++) {
|
|
MY_T_OUTPUT *Out = &Output[i];
|
|
if (Out->Encoder == Encoder_CurSelPos && Out->Handle != -1) Encoder[Encoder_CurSelPos].DisconnectOutput(Out->Handle);
|
|
}
|
|
Encoder[Encoder_CurSelPos].SetEncoder(NULL);
|
|
}
|
|
|
|
// if we can re-map the extension then we do so against the encoder selected
|
|
// which will override what was manually set but this ensures it is correct!
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
if (Out->saveEncodedPath[0] && typenum != 0) {
|
|
PathRemoveExtensionW(Out->saveEncodedPath);
|
|
PathAddExtensionW(Out->saveEncodedPath,
|
|
(Enc_LastType[Connection_CurSelPos] != 0 ?
|
|
(!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/mpeg") ? L".mp3" :
|
|
(!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/ogg") ? L".ogg" : L".aac")) : L""));
|
|
|
|
// update things as the filename was changed
|
|
SetDlgItemTextW(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, Out->saveEncodedPath);
|
|
if (Out->saveEncoded) {
|
|
StopSaveEncoded(Connection_CurSelPos);
|
|
StartSaveEncoded(Connection_CurSelPos, Out->saveEncodedPath);
|
|
}
|
|
}
|
|
|
|
SetEncoderPanelMode(hDlg, Encoder[Encoder_CurSelPos].GetEncoder());
|
|
ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
|
|
ini_modified = 1;
|
|
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_ENCODERLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_ENCODERLIST));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_ENCSETTINGS_BUTTON:
|
|
{
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
if (Enc) if (Enc->UseNsvConfig()) {
|
|
((C_ENCODER_NSV*) Enc)->Configure(hDlg, module.hDllInstance);
|
|
if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
|
|
ini_modified = 1;
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
MY_T_OUTPUT *Out = &Output[i];
|
|
if (Out->Encoder == Encoder_CurSelPos && Out->Handle != -1) {
|
|
Encoder[Encoder_CurSelPos].DisconnectOutput(Out->Handle, 1, 5);
|
|
}
|
|
}
|
|
ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
|
|
}
|
|
}
|
|
SetEncoderPanelMode(hDlg, Enc);
|
|
}
|
|
break;
|
|
|
|
case IDC_ENCSETTINGS:
|
|
{
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
T_ATTRIB attrib;
|
|
int attribnum = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
|
|
if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
|
|
C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
|
|
if (Enc) {
|
|
int i;
|
|
if (attribnum < 0 || attribnum >= Enc->GetNumAttribs()) attribnum = 0;
|
|
int oldattrib = -1;
|
|
int infosize = sizeof (T_EncoderIOVals);
|
|
T_EncoderIOVals *EncInfo = (T_EncoderIOVals *) Enc->GetExtInfo(&infosize);
|
|
for (i = Enc->GetNumAttribs() - 1; i >= 0 && oldattrib == -1; i--) {
|
|
Enc->EnumAttrib(i, &attrib);
|
|
if (attrib.OutputVals && EncInfo && infosize) {
|
|
T_ENCODER_MP3_INFO *EncSettings = (T_ENCODER_MP3_INFO *) attrib.OutputVals;
|
|
T_ENCODER_MP3_INFO *EncSettings2 = (T_ENCODER_MP3_INFO *) EncInfo;
|
|
//if (memcmp(attrib.OutputVals, EncInfo, infosize) == 0) oldattrib = i;
|
|
if(EncSettings2->output_bitRate == EncSettings->output_bitRate &&
|
|
EncSettings2->output_sampleRate == EncSettings->output_sampleRate &&
|
|
EncSettings2->output_numChannels == EncSettings->output_numChannels) {
|
|
oldattrib = i;
|
|
}
|
|
}
|
|
}
|
|
if (attribnum != oldattrib) {
|
|
if (Enc->EnumAttrib(attribnum, &attrib)) {
|
|
// we make sure that we set the input channels and samplerate to
|
|
// that of the mode being used instead of the default values as
|
|
// this allows us to get things to work correctly (done in 2.3.2)
|
|
T_ENCODER_MP3_INFO *EncSettings = (T_ENCODER_MP3_INFO *) attrib.OutputVals;
|
|
if(InputDevice == 1) {
|
|
EncSettings->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
EncSettings->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
}
|
|
Enc->ChangeSettings(EncSettings);
|
|
ini_modified = 1;
|
|
for (i = 0; i < NUM_OUTPUTS; i++) {
|
|
MY_T_OUTPUT *Out = &Output[i];
|
|
if (Out->Encoder == Encoder_CurSelPos && Out->Handle != -1) {
|
|
Encoder[Encoder_CurSelPos].DisconnectOutput(Out->Handle, 1, 5);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}//switch
|
|
}
|
|
break;
|
|
}// umsg
|
|
return CallWindowProcW((WNDPROC)DialogFunc, hDlg, uMsg, wParam, lParam);
|
|
}
|
|
|
|
/* Connection Page callback */
|
|
INT_PTR CALLBACK ConnectionFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
switch (uMsg) {
|
|
case WM_INITDIALOG:
|
|
{
|
|
switch (lParam) {
|
|
case IDD_CONNECTION:
|
|
{
|
|
int i;
|
|
wchar_t temp[128];
|
|
SendDlgItemMessage(hDlg, IDC_OUTPUTLIST, LB_RESETCONTENT, 0, 0);
|
|
for (i = 0; i < NUM_OUTPUTS; i++) {
|
|
T_OUTPUT_CONFIG *Out = &Output[i].Config;
|
|
SendDlgItemMessageW(hDlg, IDC_OUTPUTLIST, LB_ADDSTRING, 0, (LPARAM) Out->DisplayName);
|
|
}
|
|
SendDlgItemMessage(hDlg, IDC_OUTPUTLIST, LB_SETCURSEL, Connection_CurSelPos, 0);
|
|
num_outwnds = 0;
|
|
SendDlgItemMessage(hDlg, IDC_CONTAB, TCM_DELETEALLITEMS, 0, 0);
|
|
AddOutTab(IDD_PANEL_LOGIN, LocalisedString(IDS_PANEL_LOGIN, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
|
|
AddOutTab(IDD_PANEL_DIRECTORY, LocalisedString(IDS_PANEL_DIRECTORY, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
|
|
AddOutTab(IDD_ENCODER, LocalisedString(IDS_PANEL_ENCODERS, temp, 128), hDlg, EncFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
|
|
AddOutTab(IDD_PANEL_TITLE, LocalisedString(IDS_PANEL_TITLES, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
|
|
AddOutTab(IDD_ARTWORK, LocalisedString(IDS_PANEL_ART, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
|
|
AddOutTab(IDD_LOGGING, LocalisedString(IDS_PANEL_LOGGING, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
|
|
SetOutTab(curouttab, hDlg, IDC_CONTAB);
|
|
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_OUTPUTLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_OUTPUTLIST));
|
|
SendDlgItemMessage(wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK,Output[Connection_CurSelPos].AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
}
|
|
break;
|
|
}//lparam
|
|
}
|
|
return 0;
|
|
}//uMsg
|
|
return CallWindowProcW((WNDPROC)DialogFunc, hDlg, uMsg, wParam, lParam);
|
|
}
|
|
|
|
void ShowUpdateMessage(HWND hDlg)
|
|
{
|
|
bool update = (updateStr && updateStr[0]);
|
|
if (IsWindow(hDlg))
|
|
{
|
|
HWND control = GetDlgItem(hDlg, IDC_UPDATE_HEADER);
|
|
if (update)
|
|
{
|
|
wchar_t message[128] = {0};
|
|
StringCchPrintfW(message, ARRAYSIZE(message), WASABI_API_LNGSTRINGW(IDS_UPDATE_HEADER), updateStr);
|
|
|
|
SetWindowTextW(control, message);
|
|
SetBoldDialogItemFont(control);
|
|
}
|
|
else
|
|
{
|
|
SetWindowTextW(control, WASABI_API_LNGSTRINGW(IDS_UPDATE));
|
|
SendMessageW(control, WM_SETFONT, SendMessageW(hMainDLG, WM_GETFONT, 0, 0), 0);
|
|
InvalidateRect(hDlg, 0, TRUE);
|
|
}
|
|
|
|
ShowWindowDlgItem(hDlg, IDC_STATIC_UPDATE, update);
|
|
ShowWindowDlgItem(hDlg, IDC_UPDATELINK, update);
|
|
}
|
|
|
|
SetWindowTextW(hMainDLG, WASABI_API_LNGSTRINGW((update ? IDS_UPDATE_TITLE : IDS_MODULE_NAME)));
|
|
|
|
if (IsWindow(tabWnd)) {
|
|
RECT r = {0};
|
|
TabCtrl_GetItemRect(tabWnd, 3, &r);
|
|
InvalidateRect(tabWnd, &r, 0);
|
|
}
|
|
}
|
|
|
|
class VersionCheckCallback : public ifc_downloadManagerCallback
|
|
{
|
|
public:
|
|
void OnInit( DownloadToken token )
|
|
{
|
|
api_httpreceiver *http = WAC_API_DOWNLOADMANAGER->GetReceiver( token );
|
|
if ( http )
|
|
{
|
|
http->AllowCompression();
|
|
http->addheader( "Accept: */*" );
|
|
}
|
|
}
|
|
|
|
void OnFinish( DownloadToken token )
|
|
{
|
|
api_httpreceiver *http = WAC_API_DOWNLOADMANAGER->GetReceiver( token );
|
|
if ( http && http->getreplycode() == 200 )
|
|
{
|
|
char *buf = 0;
|
|
size_t size = 0;
|
|
if ( WAC_API_DOWNLOADMANAGER->GetBuffer( token, (void **)&buf, &size ) == 0 && size > 0 )
|
|
{
|
|
buf[ size - 1 ] = 0;
|
|
|
|
char *p = buf;
|
|
while ( size && ( *p == ' ' || *p == '\t' || *p == '\r' || *p == '\n' ) )
|
|
{
|
|
p++;
|
|
size--;
|
|
}
|
|
|
|
// e.g. dsp_sc,2.3.4.210,http://download.nullsoft.com/shoutcast/tools/shoutcast-dsp-2-3-4-windows.exe
|
|
if ( p && *p )
|
|
{
|
|
char *tok = strtok( p, "," );
|
|
if ( tok )
|
|
{
|
|
if ( !strncmp( tok, "dsp_sc", 6 ) )
|
|
{
|
|
tok = strtok( NULL, "," );
|
|
if ( tok )
|
|
{
|
|
bool needsUpdating = CompareVersions( tok );
|
|
lstrcpyn( updateStr, ( needsUpdating ? tok : "" ), ARRAYSIZE( updateStr ) );
|
|
WritePrivateProfileString( APP_Name, "Update", ( needsUpdating ? updateStr : 0 ), IniName );
|
|
ShowUpdateMessage( updateWnd );
|
|
if ( !needsUpdating )
|
|
{
|
|
ShowWindowDlgItem( updateWnd, IDC_STATIC_UPDATE, TRUE );
|
|
}
|
|
SetDlgItemTextW( updateWnd, IDC_STATIC_UPDATE, WASABI_API_LNGSTRINGW( ( needsUpdating ? IDS_HAS_NEW_UPDATE : IDS_NO_NEW_UPDATE ) ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( IsWindow( updateWnd ) )
|
|
{
|
|
EnableWindowDlgItem( updateWnd, IDC_GET_UPDATE, TRUE );
|
|
SetDlgItemTextW( updateWnd, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_FOR_UPDATES ) );
|
|
}
|
|
}
|
|
|
|
void OnError( DownloadToken token )
|
|
{
|
|
if ( IsWindow( updateWnd ) )
|
|
{
|
|
ShowWindowDlgItem( updateWnd, IDC_STATIC_UPDATE, TRUE );
|
|
SetDlgItemTextW( updateWnd, IDC_STATIC_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_UPDATE_FAIL ) );
|
|
EnableWindowDlgItem( updateWnd, IDC_GET_UPDATE, TRUE );
|
|
SetDlgItemTextW( updateWnd, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_FOR_UPDATES ) );
|
|
}
|
|
}
|
|
|
|
RECVS_DISPATCH;
|
|
};
|
|
|
|
#define CBCLASS VersionCheckCallback
|
|
START_DISPATCH;
|
|
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONINIT, OnInit )
|
|
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONFINISH, OnFinish )
|
|
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONERROR, OnError )
|
|
END_DISPATCH;
|
|
#undef CBCLASS
|
|
|
|
static VersionCheckCallback versionCheckCallback;
|
|
|
|
static void CheckVersion( HWND hDlg )
|
|
{
|
|
ShowWindowDlgItem( hDlg, IDC_STATIC_UPDATE, FALSE );
|
|
ShowWindowDlgItem( hDlg, IDC_UPDATELINK, FALSE );
|
|
|
|
if ( WAC_API_DOWNLOADMANAGER )
|
|
{
|
|
char url[ 128 ] = { 0 };
|
|
StringCchPrintf( url, ARRAYSIZE( url ), "http://yp.shoutcast.com/update?c=dsp_sc&v=%s&wa=%x", APP_Version, GetWinampVersion( module.hwndParent ) );
|
|
updateWnd = hDlg;
|
|
WAC_API_DOWNLOADMANAGER->DownloadEx( url, &versionCheckCallback, api_downloadManager::DOWNLOADEX_BUFFER );
|
|
}
|
|
else
|
|
{
|
|
wchar_t title[ 128 ] = { 0 }, message[ 512 ] = { 0 };
|
|
StringCchPrintfW( title, ARRAYSIZE( title ), LocalisedString( IDS_PLUGIN_NAME, NULL, 0 ), APP_VersionW );
|
|
StringCchPrintfW( message, ARRAYSIZE( message ), LocalisedString( IDS_UPDATE_CHECK_ERROR, NULL, 0 ) );
|
|
if ( MessageBoxW( module.hwndParent, message, title, MB_ICONWARNING | MB_YESNO ) == IDYES )
|
|
{
|
|
SendMessage( module.hwndParent, WM_WA_IPC, (WPARAM)DOWNLOAD_URL, IPC_OPEN_URL );
|
|
}
|
|
SetDlgItemTextW( hDlg, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_FOR_UPDATES ) );
|
|
EnableWindowDlgItem( hDlg, IDC_GET_UPDATE, TRUE );
|
|
}
|
|
}
|
|
|
|
INT_PTR CALLBACK AboutFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
if (uMsg == WM_COMMAND) {
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_ABOUTLINK:
|
|
{
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)"http://www.shoutcast.com/", IPC_OPEN_URL);
|
|
}
|
|
break;
|
|
|
|
case IDC_HELPLINK:
|
|
{
|
|
// look for a lcoal copy of the documentation otherwise then do as before and use the wiki verison
|
|
wchar_t path[MAX_PATH] = {0};
|
|
StringCchPrintfW(path, ARRAYSIZE(path), L"%s\\SHOUTcast Source DSP\\Source_DSP_Plug-in.html", GetPluginDirectoryW(module.hwndParent));
|
|
if(ShellExecuteW(module.hwndParent, L"open", path, NULL, NULL, SW_SHOWNORMAL) < (HINSTANCE)32)
|
|
{
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)L"http://wiki.shoutcast.com/wiki/Source_DSP_Plug-in", IPC_OPEN_URL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_FORUMLINK:
|
|
{
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)L"http://forums.shoutcast.com/forumdisplay.php?f=140", IPC_OPEN_URL);
|
|
}
|
|
break;
|
|
|
|
case IDC_UPDATELINK:
|
|
{
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)DOWNLOAD_URL, IPC_OPEN_URL);
|
|
}
|
|
break;
|
|
|
|
case IDC_ABOUT_ICON:
|
|
{
|
|
if (HIWORD(wParam) == STN_DBLCLK) {
|
|
static bool toggle;
|
|
SendDlgItemMessage(hDlg, IDC_ABOUT_ICON, STM_SETIMAGE, IMAGE_ICON, (LPARAM)GetICYIcon(!toggle));
|
|
SendMessage(hMainDLG, WM_SETICON, ICON_SMALL, (LPARAM)GetICYIcon(!toggle));
|
|
toggle = !toggle;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_GET_UPDATE:
|
|
{
|
|
EnableWindowDlgItem(hDlg, IDC_GET_UPDATE, FALSE);
|
|
SetDlgItemTextW(hDlg, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW(IDS_CHECKING_FOR_UPDATES));
|
|
CheckVersion(hDlg);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
LRESULT ret = CallWindowProcW((WNDPROC)DialogFunc, hDlg, uMsg, wParam, lParam);
|
|
link_handledraw(hDlg, uMsg, wParam, lParam);
|
|
return ret;
|
|
}
|
|
|
|
void UpdateTitleControls(void) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
if (Out->Config.doTitleUpdate) {
|
|
int length = (GetWindowTextLength(GetDlgItem(out_wnd[3].hWnd, IDC_TITLE)) > 0);
|
|
int sc2mode = (LOBYTE(Output[Connection_CurSelPos].Config.protocol) == 1);
|
|
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SENDNEXTTITLES, Out->AutoTitle && !sc2mode);
|
|
|
|
if (Out->AutoTitle) {
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, FALSE);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_TITLE, FALSE);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT, FALSE);
|
|
} else {
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, length);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_TITLE, TRUE);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT, !sc2mode && length);
|
|
}
|
|
} else {
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, FALSE);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_TITLE, FALSE);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT, FALSE);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SENDNEXTTITLES, FALSE);
|
|
}
|
|
}
|
|
|
|
void LockOptionControls(BOOL unlock) {
|
|
int protocol = LOBYTE(Output[Connection_CurSelPos].Config.protocol),
|
|
automatic = (HIBYTE(Output[Connection_CurSelPos].Config.protocol) == 1);
|
|
BOOL sc1 = (protocol == 1);
|
|
|
|
// First Connection panel
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_ADDRESS, unlock);
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_PORT, unlock);
|
|
// ensure the SC2 items are enabled only if SC1 mode is disabled
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_STATIONID, (sc1 ? FALSE : unlock));
|
|
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_USERID, unlock);
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_PASSWORD, unlock);
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_RECONNECT, unlock);
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_TIMEOUT, unlock);
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_PROTOCOL, unlock);
|
|
|
|
// controls the information shown on the connection panel
|
|
//ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_FRAME2, !sc1);
|
|
ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT2, (protocol == 2) && !automatic);
|
|
ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT3, (protocol == 1) && !automatic);
|
|
ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT4, automatic);
|
|
|
|
// artwork panel controls
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART, !sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, !sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_STREAM, !sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, !sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, !sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_V1_NOTE, sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ARTWORK_V1_FRAME, sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_V2_NOTE, !sc1);
|
|
ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ARTWORK_V2_FRAME, !sc1);
|
|
|
|
// Second Connection panel
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_PUBLIC, unlock);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_DESCRIPTION, unlock);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_SERVERURL, unlock);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_GENRE, FALSE);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_GENRES, unlock);
|
|
// ensure the SC1 items are enabled only if SC1 mode is enabled
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_AIM, (!sc1 ? FALSE : unlock));
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_ICQ, (!sc1 ? FALSE : unlock));
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_IRC, (!sc1 ? FALSE : unlock));
|
|
|
|
// Encoder tab
|
|
EnableWindowDlgItem(out_wnd[2].hWnd, IDC_ENCTYPE, unlock);
|
|
EnableWindowDlgItem(out_wnd[2].hWnd, IDC_ENCSETTINGS_BUTTON, unlock);
|
|
EnableWindowDlgItem(out_wnd[2].hWnd, IDC_ENCSETTINGS, unlock);
|
|
}
|
|
|
|
void WritePrivateProfileInt(LPCSTR lpKeyName, int value, LPCSTR lpAppName, LPCSTR lpFileName) {
|
|
char tmp[64] = {0};
|
|
StringCchPrintfA(tmp, ARRAYSIZE(tmp), "%u", value);
|
|
WritePrivateProfileString((!lpAppName ? APP_Name : lpAppName), lpKeyName, tmp, (!lpFileName ? IniName : lpFileName));
|
|
}
|
|
|
|
wchar_t* GetFileMetaData(wchar_t* file, wchar_t* metadata, wchar_t* buffer, int buffer_len) {
|
|
extendedFileInfoStructW efs;
|
|
efs.filename=file;
|
|
efs.metadata=metadata;
|
|
efs.ret=buffer;
|
|
efs.retlen=buffer_len;
|
|
SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)&efs, IPC_GET_EXTENDED_FILE_INFOW);
|
|
return buffer;
|
|
}
|
|
|
|
void UpdateNextTracks(wchar_t* next, int pos, std::vector<int> &nextListIdx, std::vector<std::wstring> &nextList) {
|
|
nextList.clear();
|
|
nextListIdx.clear();
|
|
|
|
int queued = (WASABI_API_QUEUEMGR ? WASABI_API_QUEUEMGR->GetNumberOfQueuedItems() : 0);
|
|
if (WASABI_API_QUEUEMGR && queued) {
|
|
for (int i = 0; i < queued && (lookAhead == -1 ? 1 : i < lookAhead); i++) {
|
|
int idx = WASABI_API_QUEUEMGR->GetQueuedItemFromIndex(i);
|
|
nextList.push_back((wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, idx, IPC_GETPLAYLISTTITLEW));
|
|
nextListIdx.push_back(idx);
|
|
}
|
|
} else {
|
|
if (next[0]) {
|
|
nextList.push_back(next);
|
|
nextListIdx.push_back(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
int GetNextTracks(int len, int pos, wchar_t* next) {
|
|
int nextpos = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETNEXTLISTPOS);
|
|
|
|
// attempt to use the new look ahead api in 5.61+ otherwise use existing
|
|
// method or if the new api returns a failure just to cover all bases
|
|
if (doNextLookAhead && nextpos != -1 && len >= 1) {
|
|
wcscpy_s((wchar_t*)next, 1024, (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, nextpos, IPC_GETPLAYLISTTITLEW));
|
|
} else {
|
|
// get the next title (as long as shuffle is off, etc)
|
|
// with it mapped back to the first track as appropriate
|
|
if (len >= 2 && !SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GET_SHUFFLE)) {
|
|
pos = (pos >= len ? 0 : pos);
|
|
wcscpy_s((wchar_t*)next, 1024, (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, pos, IPC_GETPLAYLISTTITLEW));
|
|
}
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
void FillNextTracks(int index, bool xml) {
|
|
// on change then we refresh the file as applicable
|
|
std::vector<std::wstring> nextList;
|
|
std::vector<int> nextListIdx;
|
|
wchar_t next[1024] = {0};
|
|
int curpos = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS);
|
|
int len = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTLENGTH);
|
|
int pos = curpos + 1;
|
|
pos = GetNextTracks(len, pos, next);
|
|
UpdateNextTracks(next, pos, nextListIdx, nextList);
|
|
WriteNextTracks(index, module.hwndParent, nextListIdx, nextList, xml);
|
|
}
|
|
|
|
static ARGB32 *loadImgFromFile(const wchar_t *file, int *len)
|
|
{
|
|
*len = 0;
|
|
HANDLE hf = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
|
|
if (hf != INVALID_HANDLE_VALUE)
|
|
{
|
|
*len = GetFileSize(hf, 0);
|
|
if (WASABI_API_MEMMGR) {
|
|
ARGB32* im = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(*len);
|
|
if (im) {
|
|
DWORD bytes_read;
|
|
ReadFile(hf, im, *len, &bytes_read, 0);
|
|
CloseHandle(hf);
|
|
return im;
|
|
}
|
|
}
|
|
CloseHandle(hf);
|
|
}
|
|
return (ARGB32 *)-1;
|
|
}
|
|
|
|
static wchar_t bytes[32], kilo[32], mega[32], giga[32], tera[32];
|
|
wchar_t* sizeStr(unsigned int size) {
|
|
static wchar_t temp[256];
|
|
if (GetWinampVersion(module.hwndParent) >= 0x5064) {
|
|
// TODO swap over to the native Winamp version on newer clients
|
|
return WASABI_API_LNG->FormattedSizeString(temp, ARRAYSIZE(temp), size);
|
|
} else {
|
|
if (!bytes[0]) {
|
|
LocalisedString(IDS_B, bytes, ARRAYSIZE(bytes));
|
|
LocalisedString(IDS_KIB, kilo, ARRAYSIZE(kilo));
|
|
LocalisedString(IDS_MIB, mega, ARRAYSIZE(mega));
|
|
LocalisedString(IDS_GIB, giga, ARRAYSIZE(giga));
|
|
}
|
|
|
|
if(size < 1024) {
|
|
StringCchPrintfW(temp, ARRAYSIZE(temp), L"%u %s", size, bytes);
|
|
} else if(size < 1048576) {
|
|
StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1024.0f), kilo);
|
|
} else if(size < 1073741824) {
|
|
StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1048576.0f), mega);
|
|
} else if(size < 1099511627776){
|
|
StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1073741824.0f), giga);
|
|
} else{
|
|
StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1073741824.0f), tera);
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
void UpdateArtworkMessage() {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
SHOUTCAST_OUTPUT *Enc = Out->Encoder != -1 ? &Encoder[Out->Encoder] : NULL;
|
|
wchar_t buf[1024], playing[256], stream[256];
|
|
T_OUTPUT_INFO *Info = Enc->GetOutputInfo(Out->Handle);
|
|
int streamSize = (Info ? Info->art_cached_length[0] : 0),
|
|
playingSize = (Info ? Info->art_cached_length[1] : 0);
|
|
|
|
StringCchPrintfW(stream, ARRAYSIZE(stream),
|
|
WASABI_API_LNGSTRINGW(!Out->useArt || !Out->useStreamArt ? IDS_DISABLED :
|
|
(streamSize == 0 ? IDS_EMPTY_ART : IDS_ENABLED_SIZE)),
|
|
sizeStr(streamSize));
|
|
|
|
StringCchPrintfW(playing, ARRAYSIZE(playing),
|
|
WASABI_API_LNGSTRINGW(!Out->useArt || !Out->usePlayingArt ? IDS_DISABLED :
|
|
(playingSize == 0 ? IDS_EMPTY_ART : IDS_ENABLED_SIZE)),
|
|
sizeStr(playingSize));
|
|
|
|
StringCchPrintfW(buf, ARRAYSIZE(buf), WASABI_API_LNGSTRINGW(IDS_V2_ARTWORK), stream, playing);
|
|
SetDlgItemTextW(out_wnd[4].hWnd, IDC_ART_V2_NOTE, buf);
|
|
}
|
|
|
|
void UpdatePlayingAlbumArt(int Connection, int Index, bool usePlayingArt) {
|
|
// do some quick checks as no need to send if not applicable to do so
|
|
if (!usePlayingArt && !playingImage) {
|
|
return;
|
|
}
|
|
|
|
// hard code the playing art to be sent in png format
|
|
Encoder[Index].UpdateAlbumArtCache((usePlayingArt ? playingImage : 0),
|
|
(usePlayingArt ? playingLength : 0),
|
|
playingType, Connection);
|
|
UpdateArtworkMessage();
|
|
}
|
|
|
|
bool UpdateStreamAlbumArt(int Connection, int Index, const wchar_t* stationArtPath, bool useStreamArt) {
|
|
int artType = 0x0;
|
|
bool update = false;
|
|
|
|
// if not enabled and loaded then unload and refresh
|
|
if (!useStreamArt && streamImage[Index] != (ARGB32 *)-1) {
|
|
FreeStreamAlbumArt(Index);
|
|
// bit of a fiddle to force a dummy update
|
|
artType = 0x4000;
|
|
update = true;
|
|
} else if (useStreamArt && streamImage[Index] != (ARGB32 *)-1) {
|
|
FreeStreamAlbumArt(Index);
|
|
}
|
|
|
|
// if enabled and not loaded then attempt to load
|
|
if (!update && streamImage[Index] == (ARGB32 *)-1) {
|
|
if (useStreamArt) {
|
|
streamImage[Index] = loadImgFromFile(stationArtPath, &streamLength[Index]);
|
|
|
|
wchar_t* ext = PathFindExtensionW(stationArtPath);
|
|
if (ext) {
|
|
if (*ext) ext++;
|
|
|
|
update = true;
|
|
if (!wcsnicmp(ext, L"jpeg", 4) || !wcsnicmp(ext, L"jpg", 3)) {
|
|
artType = 0x4000;
|
|
} else if (!wcsnicmp(ext, L"png", 3)) {
|
|
artType = 0x4001;
|
|
} else if (!wcsnicmp(ext, L"bmp", 3)) {
|
|
artType = 0x4002;
|
|
} else if (!wcsnicmp(ext, L"gif", 3)) {
|
|
artType = 0x4003;
|
|
} else {
|
|
update = false;
|
|
}
|
|
}
|
|
} else {
|
|
// if not enabled and not loaded then do nothing
|
|
UpdateArtworkMessage();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (update) {
|
|
Encoder[Index].UpdateAlbumArtCache((!useStreamArt || streamImage[Index] == (ARGB32 *)-1 ? 0 : streamImage[Index]),
|
|
(!useStreamArt ? 0: streamLength[Index]), artType, Connection);
|
|
}
|
|
UpdateArtworkMessage();
|
|
return update;
|
|
}
|
|
|
|
void UpdateVUMeters()
|
|
{
|
|
int volume = 0;
|
|
int vu_l = VU.vu_l;
|
|
int vu_r = VU.vu_r;
|
|
VU.vu_l = 0;
|
|
VU.vu_r = 0;
|
|
VU.lastUpdate = VU.update;
|
|
VU.update = 0;
|
|
wchar_t tmp[256], temp[32], temp2[32];
|
|
|
|
if (vu_l != 0) {
|
|
volume = (int) (20 * log10((double) vu_l));
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
|
|
} else {
|
|
volume = 0;
|
|
LocalisedString(IDS_INF_DB, tmp, 256);
|
|
}
|
|
if (volume - 90 > peak_vu_l) {
|
|
StringCchPrintfW(temp2, ARRAYSIZE(temp2), LocalisedString(IDS_X_DB_PEAK, temp, 32), (peak_vu_l = volume - 90));
|
|
SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_LP, temp2);
|
|
SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_LP, temp2);
|
|
}
|
|
|
|
SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_L, tmp);
|
|
SendDlgItemMessage(wnd[0].hWnd, IDC_VOLUMEGRAPH_L, PBM_SETPOS, volume, 0);
|
|
SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_L, tmp);
|
|
SendDlgItemMessage(wnd[2].hWnd, IDC_VOLUMEGRAPH_L, PBM_SETPOS, volume, 0);
|
|
if (vu_r != 0) {
|
|
volume = (int) (20 * log10((double) vu_r));
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
|
|
} else {
|
|
volume = 0;
|
|
LocalisedString(IDS_INF_DB, tmp, 256);
|
|
}
|
|
if (volume - 90 > peak_vu_r) {
|
|
StringCchPrintfW(temp2, ARRAYSIZE(temp2), LocalisedString(IDS_X_DB_PEAK, temp, 32), (peak_vu_r = volume - 90));
|
|
SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_RP, temp2);
|
|
SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_RP, temp2);
|
|
}
|
|
|
|
SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_R, tmp);
|
|
SendDlgItemMessage(wnd[0].hWnd, IDC_VOLUMEGRAPH_R, PBM_SETPOS, volume, 0);
|
|
SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_R, tmp);
|
|
SendDlgItemMessage(wnd[2].hWnd, IDC_VOLUMEGRAPH_R, PBM_SETPOS, volume, 0);
|
|
}
|
|
|
|
void UpdateSummaryDetails(int item) {
|
|
if (item == -1) {
|
|
return;
|
|
}
|
|
|
|
wchar_t message[2048], temp[128], temp2[128], temp3[128],
|
|
temp4[128] = {0}, temp5[128], temp6[128], temp7[128];
|
|
char temp8[128];
|
|
MY_T_OUTPUT *Out = &Output[item];
|
|
C_ENCODER *Enc = Encoder[Out->Encoder].GetEncoder();
|
|
|
|
if (Enc) {
|
|
StringCchPrintfW(temp4, ARRAYSIZE(temp4), LocalisedString(IDS_SUMMARY_KBPS, NULL, 0), ((T_EncoderIOVals*) Enc->GetExtInfo())->output_bitRate);
|
|
}
|
|
|
|
StringCchPrintfW(message, ARRAYSIZE(message), LocalisedString(IDS_SUMMARY, NULL, 0),
|
|
// TODO show automatic mode ?
|
|
(LOBYTE(Out->Config.protocol) != 1 ? 2 : 1),
|
|
LocalisedString((Out->Config.Public ? IDS_PUBLIC : IDS_PRIVATE), temp, 128),
|
|
(Out->Config.Address[0] ? Out->Config.Address : LocalisedStringA(IDS_NOT_SET_SUMMARY, temp8, 128)),
|
|
Out->Config.Port,
|
|
LocalisedString((Out->Config.doTitleUpdate ? (Out->AutoTitle ? IDS_FOLLOW_WA : IDS_MANUAL) : IDS_DISABLED), temp2, 128),
|
|
(Enc_LastType[item] != 0 ? (!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/mpeg")?L"MP3":L"AAC+") : LocalisedString(IDS_NOT_SET, temp3, 128)),
|
|
temp4,
|
|
LocalisedString((Out->Logging ? IDS_YES : IDS_NO), temp5, 128),
|
|
LocalisedString((Out->AutoConnect ? IDS_YES : IDS_NO), temp6, 128),
|
|
LocalisedString((Out->saveEncoded ? IDS_YES : IDS_NO), temp7, 128));
|
|
|
|
SetDlgItemTextW(wnd[0].hWnd, IDC_SUMMARY, message);
|
|
|
|
// see if we're looking at a incomplete setup and flag up the output tab as applicable
|
|
if (IsWindow(tabWnd)) {
|
|
RECT r = {0};
|
|
TabCtrl_GetItemRect(tabWnd, 1, &r);
|
|
if ((lastMode[item] >= 3 && lastMode[item] <= 6)) {
|
|
SetTabErrorText(tabWnd, 1, 0, &r);
|
|
} else {
|
|
InvalidateRect(tabWnd, &r, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProcessPlayingStatusUpdate(void) {
|
|
if (isplaying == 1 && SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETOUTPUTTIME)) {
|
|
if (was_paused) {
|
|
was_paused = 0;
|
|
play_diff = GetTickCount();
|
|
}
|
|
} else if (isplaying == 3) {
|
|
// pause
|
|
was_paused = 1;
|
|
} else if (isplaying == 0 && was_playing == 1) {
|
|
// stop
|
|
was_playing = was_paused = 0;
|
|
} else if (isplaying == 0 && was_playing == 0) {
|
|
// non-playing track advance
|
|
PostMessage(hMainDLG, WM_USER, 0, nowPlayingID);
|
|
}
|
|
}
|
|
|
|
// check against a list of known "illegal" names as well as not allowing
|
|
// the creation of a station with the name the same as a genre string
|
|
bool stationNameAllowed(char* name){
|
|
if(name && *name)
|
|
{
|
|
int checked = 0;
|
|
for (int i = 0; i < ARRAYSIZE(genres); i++) {
|
|
checked += !lstrcmpi(name, genres[i].name);
|
|
}
|
|
|
|
// check for punctuation only titles with double-processing
|
|
// to strip out alphanum+space and space in second and then
|
|
// we compare a difference in lengths where different is ok
|
|
if (lstrlen(name) > 0) {
|
|
char* stripped = (char*)malloc(lstrlen(name)+1);
|
|
char* stripped2 = (char*)malloc(lstrlen(name)+1);
|
|
stripped[0] = 0;
|
|
for(int i = 0, j = 0; i < lstrlen(name); i++) {
|
|
if(!isalnum(name[i]) && name[i] != ' ') {
|
|
stripped[j] = name[i];
|
|
stripped[++j] = 0;
|
|
}
|
|
}
|
|
for(int i = 0, j = 0; i < lstrlen(name); i++) {
|
|
if(name[i] != ' ') {
|
|
stripped2[j] = name[i];
|
|
stripped2[++j] = 0;
|
|
}
|
|
}
|
|
checked += !(lstrlen(stripped2) > lstrlen(stripped));
|
|
free(stripped);
|
|
free(stripped2);
|
|
}
|
|
|
|
char* invalidNames[] = {"127.0.0.1", "admin", "auto dj", "auto jedi", "auto pj",
|
|
"auto-dj", "autodj", "autopj", "demo", "dj", "internet radio",
|
|
"live", "local server", "localhost", "localserver", "music",
|
|
"my radio", "my server", "my station name", "my test server",
|
|
"n/a", "pj", "playlist", "radio", "radio station", "test",
|
|
"test server", "unnamed server", "virtual dj", "virtualdj",
|
|
"web rdio", "web radio", "song", "teste", "default stream",
|
|
"radio stream", "whmsonic autodj", "autopilot",
|
|
"this is my server name"};
|
|
for(int i = 0; i < ARRAYSIZE(invalidNames); i++)
|
|
{
|
|
checked += !lstrcmpi(name, invalidNames[i]);
|
|
}
|
|
return (!checked);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
HBITMAP WAResizeImage(HBITMAP hbmp, INT cx, INT cy) {
|
|
BITMAP bi = {0};
|
|
if (!hbmp || !GetObjectW(hbmp, sizeof(BITMAP), &bi)) return hbmp;
|
|
|
|
if (bi.bmWidth != cx || bi.bmHeight != cy) {
|
|
HDC hdc, hdcDst, hdcSrc;
|
|
HBITMAP hbmpOld1, hbmpOld2;
|
|
|
|
int ix = cy*(bi.bmWidth*1000/bi.bmHeight)/1000, iy;
|
|
if (ix > cx) {
|
|
iy = cx*(bi.bmHeight*1000/bi.bmWidth)/1000;
|
|
ix = cx;
|
|
}
|
|
else iy = cy;
|
|
|
|
hdc = GetDC(NULL);
|
|
hdcSrc = CreateCompatibleDC(hdc);
|
|
hdcDst = CreateCompatibleDC(hdc);
|
|
hbmpOld1 = (HBITMAP)SelectObject(hdcSrc, hbmp);
|
|
hbmp = CreateCompatibleBitmap(hdc, cx, cy);
|
|
hbmpOld2 = (HBITMAP)SelectObject(hdcDst, hbmp);
|
|
if (ix != cx || iy != cy) {
|
|
RECT r;
|
|
SetRect(&r, 0, 0, cx, cy);
|
|
FillRect(hdcDst, &r, GetSysColorBrush(COLOR_BTNFACE));
|
|
}
|
|
SetStretchBltMode(hdcDst, HALFTONE);
|
|
StretchBlt(hdcDst, (cx - ix)/2, (cy - iy)/2, ix, iy, hdcSrc, 0, 0, bi.bmWidth, bi.bmHeight, SRCCOPY);
|
|
|
|
SelectObject(hdcDst, hbmpOld2);
|
|
hbmpOld2 = (HBITMAP)SelectObject(hdcSrc, hbmpOld1);
|
|
if (hbmpOld2) DeleteObject(hbmpOld2);
|
|
|
|
DeleteDC(hdcSrc);
|
|
DeleteDC(hdcDst);
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
return hbmp;
|
|
}
|
|
|
|
HBITMAP getBitmap(ARGB32 * data, int w, int h)
|
|
{
|
|
BITMAPINFO info={0};
|
|
info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
info.bmiHeader.biWidth = w;
|
|
info.bmiHeader.biHeight = -h;
|
|
info.bmiHeader.biPlanes = 1;
|
|
info.bmiHeader.biBitCount = 32;
|
|
info.bmiHeader.biCompression = BI_RGB;
|
|
HDC dc = GetDC(NULL);
|
|
HBITMAP bm = CreateCompatibleBitmap(dc, w, h);
|
|
SetDIBits(dc, bm, 0, h, data, &info, DIB_RGB_COLORS);
|
|
ReleaseDC(NULL, dc);
|
|
return WAResizeImage(bm, 155, 88);
|
|
}
|
|
|
|
ARGB32 * decompressImage(const void *data, int datalen, int * dataW, int * dataH) {
|
|
ARGB32* ret=NULL;
|
|
FOURCC imgload = svc_imageLoader::getServiceType();
|
|
int n = WASABI_API_SVC->service_getNumServices(imgload);
|
|
for (int i = 0; i < n; i++) {
|
|
waServiceFactory *sf = WASABI_API_SVC->service_enumService(imgload,i);
|
|
if (sf) {
|
|
svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
|
|
if (l) {
|
|
if (l->testData(data,datalen)) {
|
|
ret = l->loadImage(data,datalen,dataW,dataH);
|
|
sf->releaseInterface(l);
|
|
break;
|
|
}
|
|
sf->releaseInterface(l);
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
INT_PTR CALLBACK DialogFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
if (SYSTRAY_BASE_MSG + SYSTRAY_MAXIMIZE_MSG == uMsg) {
|
|
int which = LOWORD(wParam) - SYSTRAY_BASE_ICON;
|
|
switch (LOWORD(lParam)) {
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
switch (which) {
|
|
case 1:
|
|
{
|
|
RemoveSystrayIcon(hDlg, SYSTRAY_ICY_ICON);
|
|
ShowWindow(hDlg, SW_SHOW);
|
|
SendMessage(hDlg, WM_SYSCOMMAND, SC_RESTORE, 0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
switch (uMsg) {
|
|
#ifdef FOLLOW_MIXER
|
|
case MM_MIXM_CONTROL_CHANGE:
|
|
{
|
|
HMIXER mix = (HMIXER)wParam;
|
|
DWORD dwControlID = (DWORD)lParam;
|
|
//if (dwControlID == 3)
|
|
{
|
|
MIXERLINE ml = {sizeof (ml), 0};
|
|
ml.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
|
|
ml.dwLineID = dwControlID;
|
|
if (mixerGetLineInfo((HMIXEROBJ) mix, &ml, MIXER_GETLINEINFOF_COMPONENTTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
|
|
MIXERLINECONTROLS mlc = {sizeof (mlc), dwControlID,};
|
|
MIXERCONTROL mc = {sizeof (mc),};
|
|
//mlc.cControls = 1;
|
|
mlc.cbmxctrl = sizeof (mc);
|
|
mlc.pamxctrl = &mc;
|
|
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
|
|
//mlc.dwControlID = dwControlID;
|
|
mlc.dwLineID = dwControlID;//ml.dwLineID;
|
|
char a[128];
|
|
sprintf(a,"MM_MIXM_CONTROL_CHANGE: %d\n",dwControlID);
|
|
OutputDebugString(a);
|
|
if (mixerGetLineControls((HMIXEROBJ) mix, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
|
|
//MIXERCONTROLDETAILS mcd = {sizeof (mcd), 0,};
|
|
char a[128];
|
|
sprintf(a,"MM_MIXM_CONTROL_CHANGE 2: %d\n",dwControlID);
|
|
OutputDebugString(a);
|
|
/*MIXERCONTROLDETAILS_UNSIGNED v[2];
|
|
mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED);
|
|
mcd.paDetails = v;
|
|
/*v[0].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
|
|
v[1].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
|
|
MMRESULT result = mixerSetControlDetails((HMIXEROBJ) hmix, &mcd, MIXER_OBJECTF_MIXER);*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case WM_LBUTTONUP:
|
|
GetWindowRect(hDlg, &mainrect);
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
{
|
|
switch (lParam) {
|
|
case IDD_DIALOG:
|
|
{
|
|
int i;
|
|
wchar_t temp[128] = {0};
|
|
hMainDLG = hDlg;
|
|
for (i = 0; i < NUM_ENCODERS; i++) Enc_mutex[i] = NULL;
|
|
INITCOMMONCONTROLSEX ICCE;
|
|
ICCE.dwSize = sizeof (ICCE);
|
|
ICCE.dwICC = ICC_WIN95_CLASSES;
|
|
InitCommonControlsEx(&ICCE);
|
|
GetSCIniFile(module.hwndParent);
|
|
VU.update = VU.lastUpdate = 0;
|
|
memset(&VU, 0, sizeof (VU));
|
|
memset(&Output, 0, sizeof (Output));
|
|
|
|
// as only 5.61+ supports the IPC_GETNEXTLISTPOS api we check and cache version now
|
|
doNextLookAhead = (GetWinampVersion(module.hwndParent) >= 0x5061);
|
|
|
|
/* Load config */
|
|
LoadConfig();
|
|
|
|
/* Load Encoders */
|
|
LoadEncoders();
|
|
|
|
/* Start logging and encoded output saving */
|
|
for (i = 0; i < NUM_OUTPUTS; i++) {
|
|
if (Output[i].Logging) {
|
|
StartLogging(i, Output[i].LogCOS);
|
|
}
|
|
if (Output[i].nextTrackLog) {
|
|
StartNextTracks(i, Output[i].nextTrackPath);
|
|
}
|
|
if (Output[i].saveEncoded) {
|
|
StartSaveEncoded(i, Output[i].saveEncodedPath);
|
|
}
|
|
}
|
|
|
|
// ensure we've cached the title information, etc as needed before starting
|
|
isplaying = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_ISPLAYING);
|
|
if (isplaying) ProcessPlayingStatusUpdate();
|
|
PostMessage(hDlg, WM_USER, 0, nowPlayingID);
|
|
|
|
/* Setup main tabs */
|
|
num_tabwnds = 0;
|
|
SendDlgItemMessage(hDlg, IDC_TAB, TCM_DELETEALLITEMS, 0, 0);
|
|
AddTab(IDD_MAIN, LocalisedString(IDS_TAB_MAIN, temp, 128), hDlg, DialogFunc, IDC_TAB, IDC_RECT, 100);
|
|
AddTab(IDD_CONNECTION, LocalisedString(IDS_TAB_OUTPUT, temp, 128), hDlg, ConnectionFunc, IDC_TAB, IDC_RECT, 100);
|
|
AddTab(IDD_INPUT, LocalisedString(IDS_TAB_INPUT, temp, 128), hDlg, DialogFunc, IDC_TAB, IDC_RECT, 100);
|
|
AddTab(IDD_ABOUT, LocalisedString(IDS_TAB_ABOUT, temp, 128), hDlg, AboutFunc, IDC_TAB, IDC_RECT, 100);
|
|
SetTab(curtab, hDlg, IDC_TAB);
|
|
|
|
/* threads and timer */
|
|
hthread = CreateThread(NULL, 0, ThreadInput, hDlg, CREATE_SUSPENDED, &threadid);
|
|
SetThreadPriority(hthread, THREAD_PRIORITY_HIGHEST);
|
|
hthreadout = CreateThread(NULL, 0, ThreadOutput, hDlg, CREATE_SUSPENDED, &threadoutid);
|
|
SetThreadPriority(hthreadout, THREAD_PRIORITY_HIGHEST);
|
|
Soundcard.Close();
|
|
Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
|
|
SetTimer(hDlg, 666, 300000, NULL); // start up INI save timer
|
|
FadeStartTime = 0;
|
|
MicFadeStartTime = 0;
|
|
FadeOut = 0;
|
|
ini_modified = 1;
|
|
ReleaseMutex(cf_mutex);
|
|
SendDlgItemMessage(wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK,Output[Connection_CurSelPos].AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
|
|
// deal with the PTT restore mode along with setting up the 'down arrow' button
|
|
SendDlgItemMessage(in_wnd[1].hWnd, IDC_LOCK, BM_SETCHECK, Restore_PTT ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
PostMessage(in_wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_LOCK, BN_CLICKED), (LPARAM)GetDlgItem(in_wnd[1].hWnd, IDC_LOCK));
|
|
|
|
SendDlgItemMessage(in_wnd[1].hWnd, IDC_LOCK_MODE, BM_SETIMAGE, IMAGE_ICON,
|
|
(LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_DOWNARROW),
|
|
IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
|
|
|
|
SendDlgItemMessage(in_wnd[1].hWnd, IDC_REFRESH_DEVICES, BM_SETIMAGE, IMAGE_ICON,
|
|
(LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_REFRESH),
|
|
IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
|
|
|
|
/* setup information parts to be in bold */
|
|
SetBoldDialogItemFont(GetDlgItem(wnd[0].hWnd, IDC_SUMMARY));
|
|
SetBoldDialogItemFont(GetDlgItem(out_wnd[1].hWnd, IDC_INFO_TEXT));
|
|
SetBoldDialogItemFont(GetDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT2));
|
|
SetBoldDialogItemFont(GetDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT3));
|
|
SetBoldDialogItemFont(GetDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT4));
|
|
SetBoldDialogItemFont(GetDlgItem(wnd[1].hWnd, IDC_CONNECT));
|
|
SetBoldDialogItemFont(GetDlgItem(out_wnd[4].hWnd, IDC_ART_V1_NOTE));
|
|
SetBoldDialogItemFont(GetDlgItem(out_wnd[4].hWnd, IDC_ART_V2_NOTE));
|
|
|
|
/* subclass the listview on the summary page for specific handling */
|
|
HWND listView = GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS);
|
|
ListView_SetItemState(listView, 0, LVIS_SELECTED, LVIS_SELECTED);
|
|
prevListViewProc = (WNDPROC) SetWindowLongPtrW(listView, GWLP_WNDPROC, (LONG_PTR) listViewProc);
|
|
prevHeaderProc = (WNDPROC) SetWindowLongPtrW(ListView_GetHeader(listView), GWLP_WNDPROC, (LONG_PTR) headerProc);
|
|
|
|
/* subclass the tab control on the main dialog for error notifications */
|
|
tabWnd = GetDlgItem(hMainDLG, IDC_TAB);
|
|
prevTabWndProc = (WNDPROC) SetWindowLongPtrW(tabWnd, GWLP_WNDPROC, (LONG_PTR) tabWndProc);
|
|
|
|
/* subclass the tab control on the connection page for error notifications */
|
|
outTabWnd = GetDlgItem(wnd[1].hWnd, IDC_CONTAB);
|
|
prevOutTabWndProc = (WNDPROC) SetWindowLongPtrW(outTabWnd, GWLP_WNDPROC, (LONG_PTR) outTabWndProc);
|
|
|
|
/* only once everything else has been done then we start the threads */
|
|
ResumeThread(hthread);
|
|
ResumeThread(hthreadout);
|
|
break;
|
|
}
|
|
|
|
case IDD_MAIN:
|
|
{
|
|
HWND listView = GetDlgItem(hDlg, IDC_OUTPUTSTATUS);
|
|
ListView_DeleteAllItems(listView);
|
|
ListView_SetExtendedListViewStyle(listView, LVS_EX_FULLROWSELECT|LVS_EX_DOUBLEBUFFER|LVS_EX_LABELTIP);
|
|
AddColumn(L"", listView);
|
|
AddColumn(LocalisedString(IDS_COL_OUTPUT_NAME, NULL, 0), listView);
|
|
AddColumn(LocalisedString(IDS_COL_STATUS, NULL, 0), listView);
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
AddColItem(L"", 0, hDlg, IDC_OUTPUTSTATUS);
|
|
AddColItem(Output[i].Config.DisplayName, 1, hDlg, IDC_OUTPUTSTATUS);
|
|
AddColItem(L"", 2, hDlg, IDC_OUTPUTSTATUS);
|
|
}
|
|
|
|
// fill the header of the output list with the column headers
|
|
ListView_SetColumnWidth(listView, 0, 24);//LVSCW_AUTOSIZE_USEHEADER);
|
|
ListView_SetColumnWidth(listView, 1, LVSCW_AUTOSIZE_USEHEADER);
|
|
int width = ListView_GetColumnWidth(listView, 0) + ListView_GetColumnWidth(listView, 1);
|
|
RECT listViewRect;
|
|
GetClientRect(listView, &listViewRect);
|
|
ListView_SetColumnWidth(listView, 2, (listViewRect.right - listViewRect.left) - width);
|
|
|
|
// add in status / action buttons for the first column...
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
POINT pt;
|
|
ListView_GetItemPosition(listView, i, &pt);
|
|
ListView_GetItemRect(listView, i, &listViewRect, LVIR_BOUNDS);
|
|
buttonWnd[i] = CreateWindowW(L"button", L"", WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_DISABLED | BS_ICON,
|
|
1, pt.y, ListView_GetColumnWidth(listView, 0) - 3,
|
|
(listViewRect.bottom - listViewRect.top),
|
|
listView, (HMENU)(IDC_STREAM_1+i), 0, 0);
|
|
SendMessage(buttonWnd[i], BM_SETIMAGE, IMAGE_ICON,
|
|
(LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_PLAY),
|
|
IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
|
|
}
|
|
|
|
CheckRadioButton(hDlg, IDC_INPUT_WINAMP, IDC_INPUT_SOUNDCARD, (IDC_INPUT_WINAMP + InputDevice));
|
|
SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_L, PBM_SETRANGE, 0, MAKELONG(0, 90));
|
|
SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_R, PBM_SETRANGE, 0, MAKELONG(0, 90));
|
|
for (int ii = 0; ii < NUM_OUTPUTS; ii++) {
|
|
int encnum = ii;
|
|
MY_T_OUTPUT *Out = &Output[ii];
|
|
// removed encoder selection
|
|
if (Out->Encoder != -1) {
|
|
if (Out->Handle != -1) {
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[Out->Encoder].RemoveOutput(Out->Handle);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
}
|
|
|
|
Out->Encoder = encnum;
|
|
if (Out->Encoder != -1) {
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Out->Handle = Encoder[Out->Encoder].AddOutput(Out->Encoder, &Out->Config, TitleCallback);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
ini_modified = 1;
|
|
}
|
|
// TODO
|
|
//SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_NOTITLES, BN_CLICKED), (LPARAM) GetDlgItem(hDlg, IDC_NOTITLES));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IDD_INPUT:
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_INPUTDEVICE, CB_RESETCONTENT, 0, 0);
|
|
AddInTab(IDD_PANEL_WINAMP, LocalisedString(IDS_INPUT_WINAMP, NULL, 0), hDlg);
|
|
AddInTab(IDD_PANEL_LINEIN, LocalisedString(IDS_INPUT_SOUNDCARD, NULL, 0), hDlg);
|
|
SetInTab(InputDevice, hDlg, IDC_INPUTDEVICE);
|
|
EnableWindowDlgItem(hDlg, IDC_INPUTDEVICE, 1);
|
|
EnableWindowDlgItem(hDlg, IDC_INPUTDEVICESTATIC, 1);
|
|
SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_L, PBM_SETRANGE, 0, MAKELONG(0, 90));
|
|
SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_R, PBM_SETRANGE, 0, MAKELONG(0, 90));
|
|
break;
|
|
}
|
|
|
|
case IDD_ABOUT:
|
|
{
|
|
// this will make sure that we've got the icon shown even when using a localised version
|
|
// as well as setting the dialog icon to the icy icon irrespective of the dialog class's
|
|
SendDlgItemMessage(hDlg, IDC_ABOUT_ICON, STM_SETIMAGE, IMAGE_ICON, (LPARAM)GetICYIcon());
|
|
SendMessage(hMainDLG, WM_SETICON, ICON_SMALL, (LPARAM)GetICYIcon());
|
|
|
|
wchar_t about[1024], tmp[256];
|
|
StringCchPrintfW(about, ARRAYSIZE(about), LocalisedString(IDS_ABOUT_MESSAGE, NULL, 0),
|
|
LocalisedString(IDS_MODULE_NAME, tmp, 256),
|
|
APP_Version, APP_Build, __DATE__);
|
|
SetDlgItemTextW(hDlg, IDC_PROGRAMNAME, about);
|
|
link_startsubclass(hDlg, IDC_ABOUTLINK);
|
|
link_startsubclass(hDlg, IDC_HELPLINK);
|
|
link_startsubclass(hDlg, IDC_FORUMLINK);
|
|
link_startsubclass(hDlg, IDC_UPDATELINK);
|
|
|
|
ShowUpdateMessage(hDlg);
|
|
break;
|
|
}
|
|
|
|
case IDD_PANEL_WINAMP:
|
|
{
|
|
wchar_t buf[128] = {0};
|
|
inWinWa = hDlg;
|
|
HWND metalist = GetDlgItem(hDlg, IDC_METALIST);
|
|
ListView_SetExtendedListViewStyle(metalist, LVS_EX_FULLROWSELECT|LVS_EX_DOUBLEBUFFER|LVS_EX_LABELTIP);
|
|
AddColumn(L"", metalist);
|
|
AddColumn(L"", metalist);
|
|
AddColItem(LocalisedString(IDS_FILEPATH, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
AddColItem(LocalisedString(IDS_TITLE, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
AddColItem(LocalisedString(IDS_ARTIST, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
AddColItem(LocalisedString(IDS_ALBUM, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
AddColItem(LocalisedString(IDS_GENRE, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
AddColItem(LocalisedString(IDS_YEAR, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
AddColItem(LocalisedString(IDS_COMMENT, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
|
|
ListView_SetColumnWidth(metalist, 0, LVSCW_AUTOSIZE);
|
|
RECT metalistRect;
|
|
GetClientRect(metalist, &metalistRect);
|
|
ListView_SetColumnWidth(metalist, 1, (metalistRect.right - metalistRect.left) - ListView_GetColumnWidth(metalist, 0));
|
|
break;
|
|
}
|
|
|
|
case IDD_PANEL_LINEIN:
|
|
{
|
|
inWin = NULL;
|
|
prevButtonProc = (WNDPROC) SetWindowLongPtrW(GetDlgItem(hDlg, IDC_PTT), GWLP_WNDPROC, (LONG_PTR) buttonProc);
|
|
SendDlgItemMessage(hDlg, IDC_MUSSLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
|
|
SendDlgItemMessage(hDlg, IDC_MUS2SLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
|
|
SendDlgItemMessage(hDlg, IDC_MICSLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
|
|
SendDlgItemMessage(hDlg, IDC_FADESLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 25));
|
|
SendDlgItemMessage(hDlg, IDC_MICFADESLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 25));
|
|
SendDlgItemMessage(hDlg, IDC_MUSSLIDER, TBM_SETPOS, TRUE, MusVol);
|
|
SendDlgItemMessage(hDlg, IDC_MUS2SLIDER, TBM_SETPOS, TRUE, Mus2Vol);
|
|
SendDlgItemMessage(hDlg, IDC_MICSLIDER, TBM_SETPOS, TRUE, MicVol);
|
|
SendDlgItemMessage(hDlg, IDC_FADESLIDER, TBM_SETPOS, TRUE, FadeTime);
|
|
SendDlgItemMessage(hDlg, IDC_MICFADESLIDER, TBM_SETPOS, TRUE, MicFadeTime);
|
|
SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MUSSLIDER));
|
|
SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MUS2SLIDER));
|
|
SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MICSLIDER));
|
|
SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_FADESLIDER));
|
|
SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MICFADESLIDER));
|
|
inWin = hDlg;
|
|
SetDeviceName();
|
|
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_DEVBOX, CBN_SELCHANGE), (LPARAM)GetDlgItem(hDlg,IDC_DEVBOX));
|
|
break;
|
|
}
|
|
|
|
case IDD_PANEL_LOGIN:
|
|
{
|
|
SendDlgItemMessageW(hDlg, IDC_PROTOCOL, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_AUTOMATIC, NULL, 0));
|
|
SendDlgItemMessage(hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 0,(LPARAM)0);
|
|
SendDlgItemMessageW(hDlg, IDC_PROTOCOL, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_V2_MODE, NULL, 0));
|
|
SendDlgItemMessage(hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 1,(LPARAM)2);
|
|
SendDlgItemMessageW(hDlg, IDC_PROTOCOL, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_V1_MODE, NULL, 0));
|
|
SendDlgItemMessage(hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 2,(LPARAM)1);
|
|
SendDlgItemMessage(hDlg, IDC_TIMEOUT, EM_SETLIMITTEXT, 5, 0);
|
|
break;
|
|
}
|
|
|
|
case IDD_PANEL_DIRECTORY:
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_GENRES, BM_SETIMAGE, IMAGE_ICON,
|
|
(LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_DOWNARROW),
|
|
IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
|
|
case WM_CLOSE:
|
|
{
|
|
if (hDlg == hMainDLG)
|
|
{
|
|
doQuit();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_USER:
|
|
{
|
|
if (lParam == nowPlayingID && wParam == 0) {
|
|
// Winamp Title handling
|
|
wchar_t title[1024] = {0},
|
|
next[1024] = {0},
|
|
song[1024] = {0},
|
|
artist[1024] = {0},
|
|
album[1024] = {0},
|
|
genre[1024] = {0},
|
|
comment[1024] = {0},
|
|
year[32] = {0},
|
|
tmp2[1024] = {0};
|
|
char buffer[1024] = {0},
|
|
buffer2[1024] = {0};
|
|
|
|
// winamp playlist length in tracks
|
|
int len = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTLENGTH);
|
|
int curpos = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS);
|
|
int pos = curpos + 1;
|
|
int len2 = 0;
|
|
|
|
// get the current title
|
|
if (len >= 1) {
|
|
wcscpy_s(lastFile, MAX_PATH, (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, curpos, IPC_GETPLAYLISTFILEW));
|
|
wcscpy_s(title, ARRAYSIZE(title), (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, curpos, IPC_GETPLAYLISTTITLEW));
|
|
} else {
|
|
title[0] = lastFile[0] = 0;
|
|
}
|
|
|
|
// get the position of the next track if possible
|
|
pos = GetNextTracks(len, pos, next);
|
|
|
|
if (skipMetada == false) {
|
|
AddColItem(lastFile, 1, inWinWa, IDC_METALIST, 0);
|
|
GetFileMetaData(lastFile, L"title", song, ARRAYSIZE(song));
|
|
AddColItem((song && song[0] ? song : title), 1, inWinWa, IDC_METALIST, 1);
|
|
GetFileMetaData(lastFile, L"artist", artist, ARRAYSIZE(artist));
|
|
AddColItem((artist[0] ? artist : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 2);
|
|
GetFileMetaData(lastFile, L"album", album, ARRAYSIZE(album));
|
|
AddColItem((album[0] ? album : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 3);
|
|
GetFileMetaData(lastFile, L"genre", genre, ARRAYSIZE(genre));
|
|
AddColItem((genre[0] ? genre : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 4);
|
|
GetFileMetaData(lastFile, L"year", year, ARRAYSIZE(year));
|
|
AddColItem((year[0] ? year : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 5);
|
|
GetFileMetaData(lastFile, L"comment", comment, ARRAYSIZE(comment));
|
|
AddColItem((comment[0] ? comment : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 6);
|
|
|
|
if (WASABI_API_MEMMGR && playingImage) {
|
|
WASABI_API_MEMMGR->sysFree(playingImage); playingImage = 0;
|
|
}
|
|
|
|
playingLength = 0;
|
|
playingType = 0x4100; // default in-case of issue
|
|
|
|
// attempt to get the type of the image, defaulting to jpeg for older versions
|
|
// as only on 5.64+ are we able to query Winamp properly for the artwork type
|
|
wchar_t* mimeType = 0, *uiType = L"jpeg";
|
|
if (GetWinampVersion(module.hwndParent) >= 0x5064)
|
|
{
|
|
LPVOID bits;
|
|
size_t len;
|
|
if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArtData(lastFile, L"cover", &bits, &len, &mimeType) == ALBUMART_SUCCESS) {
|
|
// make sure to free the original image after we've converted
|
|
playingImage = (ARGB32 *)bits;
|
|
playingLength = len;
|
|
|
|
wchar_t *ext = &mimeType[0];
|
|
if (ext && *ext) {
|
|
uiType = ext;
|
|
if (!wcsnicmp(ext, L"jpeg", 4) || !wcsnicmp(ext, L"jpg", 3)) {
|
|
playingType = 0x4100;
|
|
} else if (!wcsnicmp(ext, L"png", 3)) {
|
|
playingType = 0x4101;
|
|
} else if (!wcsnicmp(ext, L"bmp", 3)) {
|
|
playingType = 0x4102;
|
|
} else if (!wcsnicmp(ext, L"gif", 3)) {
|
|
playingType = 0x4103;
|
|
}
|
|
}
|
|
|
|
// update the current artwork on the winamp panel
|
|
// have to decode as we get the raw data normally
|
|
HWND artwork = GetDlgItem(inWinWa, IDC_ARTWORK);
|
|
HBITMAP bm = getBitmap(decompressImage(playingImage, playingLength, &playingImage_w, &playingImage_h), playingImage_w, playingImage_h);
|
|
HBITMAP bmold = (HBITMAP)SendMessage(artwork, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)bm);
|
|
if (bmold) DeleteObject(bmold);
|
|
InvalidateRect(artwork, NULL, TRUE);
|
|
}
|
|
} else {
|
|
playingImage_w = 0, playingImage_h = 0;
|
|
if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArt(lastFile, L"cover", &playingImage_w, &playingImage_h, &playingImage) == ALBUMART_SUCCESS) {
|
|
// make sure to free the original image after we've converted
|
|
ARGB32 *firstPlayingImage = playingImage;
|
|
|
|
// update the current artwork on the winamp panel
|
|
// no need to decode as it's already done by this
|
|
HWND artwork = GetDlgItem(inWinWa, IDC_ARTWORK);
|
|
HBITMAP bm = getBitmap(playingImage, playingImage_w, playingImage_h);
|
|
HBITMAP bmold = (HBITMAP)SendMessage(artwork, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)bm);
|
|
if (bmold) DeleteObject(bmold);
|
|
InvalidateRect(artwork, NULL, TRUE);
|
|
|
|
playingImage = writeImg(playingImage, playingImage_w, playingImage_h, &playingLength, L"jpeg");
|
|
WASABI_API_MEMMGR->sysFree(firstPlayingImage);
|
|
} else {
|
|
playingImage = 0;
|
|
}
|
|
}
|
|
|
|
wchar_t tmp3[1024] = {0};
|
|
if(playingImage)
|
|
{
|
|
StringCchPrintfW(tmp3, ARRAYSIZE(tmp3), L"Playing Artwork: Width=%d; Height=%d; Data=%s;",
|
|
playingImage_w, playingImage_h, sizeStr(playingLength));
|
|
|
|
// only use this on compatible Winamp installs where possible
|
|
wchar_t *mime = 0;
|
|
if (GetWinampVersion(module.hwndParent) >= 0x5064 &&
|
|
AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArtOrigin(lastFile, L"cover", &mime)) {
|
|
if (mime)
|
|
{
|
|
uiType = wcschr(mime, L'/');
|
|
if (uiType && *uiType)
|
|
{
|
|
uiType++;
|
|
}
|
|
}
|
|
} else {
|
|
if (mimeType)
|
|
{
|
|
uiType = wcschr(mimeType, L'/');
|
|
if (uiType && *uiType)
|
|
{
|
|
uiType++;
|
|
}
|
|
}
|
|
}
|
|
|
|
wchar_t buf[256] = {0};
|
|
StringCchPrintfW(buf, ARRAYSIZE(buf), LocalisedString(IDS_ARTWORK_SIZES, NULL, 0),
|
|
playingImage_w, playingImage_h, sizeStr(playingLength),
|
|
(uiType && *uiType ? uiType : mime));
|
|
SetDlgItemTextW(inWinWa, IDC_ARTWORK3, buf);
|
|
WASABI_API_MEMMGR->sysFree(mime);
|
|
}
|
|
else
|
|
{
|
|
// update the current artwork on the winamp panel
|
|
// by setting a generic image when nothing loaded
|
|
HWND artwork = GetDlgItem(inWinWa, IDC_ARTWORK);
|
|
HBITMAP bmold = (HBITMAP)SendMessage(artwork, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)0);
|
|
if (bmold) DeleteObject(bmold);
|
|
SetDlgItemTextW(inWinWa, IDC_ARTWORK3, L"");
|
|
StringCchPrintfW(tmp3, ARRAYSIZE(tmp3), L"Playing Artwork: Cleared;");
|
|
}
|
|
if (mimeType) WASABI_API_MEMMGR->sysFree(mimeType);
|
|
ShowWindowDlgItem(inWinWa, IDC_ARTWORK, (playingLength > 0));
|
|
ShowWindowDlgItem(inWinWa, IDC_ARTWORK2, (playingLength == 0));
|
|
ShowWindowDlgItem(inWinWa, IDC_ARTWORK3, (playingLength > 0));
|
|
CreateLogFileMessage(buffer2, tmp3, &len2);
|
|
}
|
|
|
|
// look at the playback queue so we can get the correct 'next song'
|
|
if (WASABI_API_SVC && !WASABI_API_QUEUEMGR) {
|
|
// due to loading orders its possible the queue won't have been loaded on init so check
|
|
ServiceBuild(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
|
|
}
|
|
|
|
std::vector<std::wstring> nextList;
|
|
std::vector<int> nextListIdx;
|
|
UpdateNextTracks(next, pos, nextListIdx, nextList);
|
|
|
|
StringCchPrintfW(tmp2, ARRAYSIZE(tmp2), L"Metadata: Artist=%s; Album=%s; Genre=%s; Year=%s; Comment=%s; Title=%s;",
|
|
artist, album, genre, year, comment, (song && song[0] ? song : title));
|
|
len = 0;
|
|
CreateLogFileMessage(buffer, tmp2, &len);
|
|
|
|
// update the title cache for all of the encoders otherwise we might fail, etc
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
MY_T_OUTPUT *Out = &Output[i];
|
|
|
|
if (Out->nextTrackLog) {
|
|
WriteNextTracks(i, module.hwndParent, nextListIdx, nextList, !!Out->nextTrackLogXML);
|
|
}
|
|
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[i].UpdateTitleCache(title, nextList, song, album, artist, genre, comment, year, Out->Handle, !!Out->NextTitles);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
|
|
// skip this all if the mode is not enabled and only in SC2 mode
|
|
if ((LOBYTE(Out->Config.protocol) != 1) && Out->useArt) {
|
|
// this will only update generally on first connection
|
|
if (Out->useStreamArt && streamImage[i] == (ARGB32 *)-1) {
|
|
UpdateStreamAlbumArt(Out->Handle, i, Out->stationArtPath, !!Out->useStreamArt);
|
|
}
|
|
|
|
// this will update against what is read from the playing
|
|
if (Out->usePlayingArt) {
|
|
UpdatePlayingAlbumArt(Out->Handle, i, Out->useArt && Out->usePlayingArt);
|
|
}
|
|
}
|
|
|
|
// save the updated metadata to the log file (if enabled)
|
|
if (Out->Logging && logFiles[i] != INVALID_HANDLE_VALUE) {
|
|
DWORD written = 0;
|
|
WriteFile(logFiles[i], buffer, len, &written, 0);
|
|
WriteFile(logFiles[i], buffer2, len2, &written, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
{
|
|
if (wParam == IDD_MAIN || wParam == IDD_INPUT) {
|
|
if (VU.update || VU.update != VU.lastUpdate)
|
|
{
|
|
UpdateVUMeters();
|
|
}
|
|
}
|
|
|
|
if (wParam == 1234) { // input timer
|
|
if (InputDevice == 1) {
|
|
for (int i = 0; i < NUM_BUFFERS; i++) {
|
|
if (Soundcard.isFilled(last_buffer)) {
|
|
short *buffer = Soundcard[last_buffer];
|
|
int scardsmps = Soundcard.getNumSamples(last_buffer);
|
|
int numsamps = scardsmps * InputConfig.nch;
|
|
if (!VU.update) {
|
|
for (int j = 0; j < numsamps; j++) {
|
|
if (VU.vu_l < buffer[j]) VU.vu_l = buffer[j];
|
|
if (LineInputAttribs[Input_CurSelPos].nch == 2) {
|
|
if (VU.vu_r < buffer[j + 1]) VU.vu_r = buffer[j + 1];
|
|
j++;
|
|
}
|
|
}
|
|
if (LineInputAttribs[Input_CurSelPos].nch == 1) VU.vu_r = VU.vu_l;
|
|
VU.update = 1;
|
|
}
|
|
if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
|
|
Crossfader->put(buffer, scardsmps);
|
|
ReleaseMutex(cf_mutex);
|
|
}
|
|
Soundcard.cycleBuffer(last_buffer++);
|
|
if (last_buffer >= NUM_BUFFERS) last_buffer = 0;
|
|
}
|
|
}
|
|
}
|
|
} else if (wParam == IDD_MAIN || wParam == IDD_CONNECTION ||
|
|
wParam == IDD_INPUT || wParam == IDD_ABOUT) {
|
|
wchar_t title[1024] = {0};
|
|
wchar_t next[1024] = {0};
|
|
int states[NUM_OUTPUTS] = {OUT_ERROR,OUT_ERROR,OUT_ERROR,OUT_ERROR,OUT_ERROR};
|
|
|
|
for (int i = 0; i < NUM_OUTPUTS; i++) {
|
|
wchar_t tmp[1024] = {0};
|
|
static wchar_t old_tmp[NUM_ENCODERS][1024] = {0};
|
|
MY_T_OUTPUT *Out = &Output[i];
|
|
SHOUTCAST_OUTPUT *Enc = Out->Encoder != -1 ? &Encoder[Out->Encoder] : NULL;
|
|
bool encoder_ok = false;
|
|
if (Enc) {
|
|
C_ENCODER *Encoder = Enc->GetEncoder();
|
|
if (Encoder) {
|
|
if (strcmp(Encoder->GetName(), "MP3 Encoder") == 0) {
|
|
encoder_ok = (libinst != NULL);
|
|
} else {
|
|
encoder_ok = true;
|
|
}
|
|
}
|
|
}
|
|
lastEnable[i] = (encoder_ok && Out->Config.Address[0] && Out->Config.Password[0] &&
|
|
stationNameAllowed(Out->Config.Description));
|
|
|
|
if (Out->Encoder == -1 || Out->Handle == -1) {
|
|
LocalisedString(IDS_NOT_CONNECTED, tmp, ARRAYSIZE(tmp));
|
|
if (wParam == IDD_CONNECTION && i == Connection_CurSelPos) {
|
|
GetDlgItemTextW(out_wnd[3].hWnd, IDC_TITLE, title, sizeof (title) / sizeof (wchar_t));
|
|
GetDlgItemTextW(out_wnd[3].hWnd, IDC_NEXT, next, sizeof (next) / sizeof (wchar_t));
|
|
}
|
|
} else {
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
T_OUTPUT_INFO *Info = Enc->GetOutputInfo(Out->Handle);
|
|
if (title != NULL && next != NULL && Info != NULL) {
|
|
if (Info->Title)
|
|
{
|
|
free(Info->Title);
|
|
}
|
|
Info->Title = _wcsdup(title);
|
|
}
|
|
|
|
states[i] = Enc->GetState(Out->Handle);
|
|
switch (states[i]) {
|
|
case OUT_ERROR:
|
|
{
|
|
LocalisedString(IDS_ERROR, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_DISCONNECTED:
|
|
{
|
|
if (Info->Succeeded < 0) {
|
|
if (Info->ErrorMsg && Info->ErrorMsg[0]) {
|
|
// if an error is reported, try to give a user-friendly error message
|
|
if (!strcmp("NAK:Deny", Info->ErrorMsg))
|
|
// localised Password error
|
|
LocalisedString(IDS_PASS_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("CipherFail",Info->ErrorMsg))
|
|
// localised cipher error
|
|
LocalisedString(IDS_CIPHER_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("BitrateError",Info->ErrorMsg))
|
|
// localised bitrate error (not allowed / not supported)
|
|
LocalisedString(IDS_BITRATE_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("StreamID",Info->ErrorMsg))
|
|
// localised stream moved error
|
|
LocalisedString(IDS_STREAMID_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("StreamMoved",Info->ErrorMsg))
|
|
LocalisedString(IDS_STREAM_MOVED_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("VersionError",Info->ErrorMsg))
|
|
// localised version error
|
|
LocalisedString(IDS_VERSION_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("Blocked",Info->ErrorMsg))
|
|
// localised blocked error
|
|
LocalisedString(IDS_BLOCKED_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("InUse",Info->ErrorMsg))
|
|
// localised in use error
|
|
LocalisedString(IDS_IN_USE_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else if (!strcmp("ParseError",Info->ErrorMsg))
|
|
// localised parse error
|
|
LocalisedString(IDS_PARSE_ERROR, tmp, ARRAYSIZE(tmp));
|
|
else
|
|
// non localised dynamic nak error
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), L"%hs", Info->ErrorMsg);
|
|
} else {
|
|
// localised Password error
|
|
LocalisedString(IDS_PASS_ERROR, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
Out->Config.AutoRecon = 0;
|
|
} else {
|
|
if (Info->last_state == OUT_RECV_CIPHER ||
|
|
Info->last_state == OUT_REQUEST_CIPHER) {
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_ENABLE_OTHER_MODE, NULL, 0), (Info->last_state == OUT_RECV_CIPHER ? 1 : 2));
|
|
} else {
|
|
LocalisedString((lastEnable[i] ? IDS_NOT_CONNECTED : IDS_NOT_CONFIGURED), tmp, ARRAYSIZE(tmp));
|
|
}
|
|
lastSec[i] = 0;
|
|
}
|
|
}
|
|
break;
|
|
case OUT_CONNECT:
|
|
{
|
|
if ((clock() - Info->ConnectionTime) / CLOCKS_PER_SEC < 1) {
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_RECONNECTING_X, NULL, 0), 1);
|
|
} else {
|
|
LocalisedString(IDS_CONNECTING, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
}
|
|
break;
|
|
case OUT_REQUEST_CIPHER:
|
|
{
|
|
LocalisedString(IDS_SEND_CIPHER_REQUEST, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_CIPHER:
|
|
{
|
|
LocalisedString(IDS_CIPHER_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SENDAUTH:
|
|
{
|
|
LocalisedString(IDS_SENDING_AUTH, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECVAUTHRESPONSE:
|
|
{
|
|
LocalisedString(IDS_RECEIVING_AUTH_RESPONSE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_MIME:
|
|
{
|
|
LocalisedString(IDS_SENDING_CONTENT_TYPE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_MIME:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_BITRATE:
|
|
{
|
|
LocalisedString(IDS_SENDING_BITRATE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_BITRATE:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_BUFSIZE:
|
|
{
|
|
LocalisedString(IDS_SEND_BUF_SIZE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_BUFSIZE:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_MAX:
|
|
{
|
|
LocalisedString(IDS_SEND_MAX_PAYLOAD_SIZE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_MAX:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SENDYP:
|
|
{
|
|
LocalisedString(IDS_SEND_YP_INFO, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_INITFLUSH:
|
|
{
|
|
LocalisedString(IDS_SEND_FLUSH, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_INITFLUSH:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_INITSTANDBY:
|
|
{
|
|
LocalisedString(IDS_SEND_STANDBY, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_INITSTANDBY:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
/*case OUT_SEND_INTRO:
|
|
{
|
|
LocalisedString(IDS_SEND_INTRO_FILE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_INTRO:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_SEND_BACKUP:
|
|
{
|
|
LocalisedString(IDS_SEND_BACKUP_FILE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECV_BACKUP:
|
|
{
|
|
LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;*/
|
|
case OUT_SEND_ARTWORK:
|
|
case OUT_SEND_METADATA:
|
|
break;
|
|
case OUT_SENDCONTENT:
|
|
{
|
|
time_t time_value = time(NULL) - Info->ConnectedAt;
|
|
long hour = (long)(time_value/3600);
|
|
long min = (time_value/60)%60;
|
|
long sec = time_value%60;
|
|
static wchar_t format[256];
|
|
if (!format[0]) LocalisedString(IDS_SENT_X, format, ARRAYSIZE(format));
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), format, hour, min, sec, sizeStr(Info->BytesSent));
|
|
lastSec[i] = sec;
|
|
|
|
// do this to filter out some of the log
|
|
// events so it'll only happen every second
|
|
if (lastSec[i] == sec - 1) {
|
|
secChanged[i] = true;
|
|
}
|
|
}
|
|
break;
|
|
case OUT_DISCONNECT:
|
|
{
|
|
LocalisedString(IDS_DISCONNECTING, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
case OUT_RECONNECT:
|
|
{
|
|
if (Info->Reconnect) {
|
|
int seconds = Info->ReconnectTime - ((clock() - Info->ConnectionTime) / CLOCKS_PER_SEC);
|
|
if (seconds > 0) {
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_RECONNECTING_X, NULL, 0), seconds);
|
|
} else {
|
|
if (Info->Switching) {
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_SWITCHING_PROTOCOL, NULL, 0),
|
|
(Info->Switching == 2 ? 2 : 1), (Info->Switching == 2 ? 1 : 2));
|
|
} else {
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_RECONNECTING_X, NULL, 0), seconds);
|
|
}
|
|
}
|
|
} else {
|
|
if (Info->Switching) {
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_SWITCHING_PROTOCOL, NULL, 0),
|
|
(Info->Switching == 2 ? 2 : 1), (Info->Switching == 2 ? 1 : 2));
|
|
} else {
|
|
LocalisedString(IDS_DISCONNECTING, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case OUT_TITLESENDUPDATE:
|
|
{
|
|
LocalisedString(IDS_SEND_TITLE_UPDATE, tmp, ARRAYSIZE(tmp));
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (Out->AutoConnect && states[i] == OUT_DISCONNECTED) {
|
|
Enc->ConnectOutput(Out->Handle);
|
|
}
|
|
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
|
|
// output log messages to the log files if enabled
|
|
// but filter things a bit more with the sent state
|
|
if (tmp[0] && wcsnicmp(old_tmp[i], tmp, ARRAYSIZE(tmp))) {
|
|
if (Out->Logging && logFiles[i] != INVALID_HANDLE_VALUE) {
|
|
if (states[i] != OUT_SENDCONTENT || (states[i] == OUT_SENDCONTENT && secChanged[i] == true)) {
|
|
DWORD written = 0;
|
|
int len = 0;
|
|
char buffer[1024];
|
|
if (states[i] == OUT_CONNECT) {
|
|
wchar_t tmp2[2048] = {0};
|
|
int protocol = (LOBYTE(Out->Config.protocol) != 1 ? 2 : 1);
|
|
StringCchPrintfW(tmp2, ARRAYSIZE(tmp2),
|
|
L"Connecting to... Server: %hs; Port: %d; Mode: v%d; Stream ID: %hs; DJ / User ID: %hs",
|
|
Out->Config.Address, Out->Config.Port, protocol,
|
|
(protocol == 1 ? "n/a" : Out->Config.StationID),
|
|
(!Out->Config.UserID[0] ? "n/a" : Out->Config.UserID));
|
|
CreateLogFileMessage(buffer, tmp2, &len);
|
|
WriteFile(logFiles[i], buffer, len, &written, 0);
|
|
} else {
|
|
CreateLogFileMessage(buffer, tmp, &len);
|
|
WriteFile(logFiles[i], buffer, len, &written, 0);
|
|
}
|
|
}
|
|
}
|
|
secChanged[i] = false;
|
|
}
|
|
|
|
// update summary and output page view and text states as applicable
|
|
if (wParam == IDD_MAIN ||
|
|
(wParam == IDD_CONNECTION && i == Connection_CurSelPos)) {
|
|
// update status text for the output being processed
|
|
if (tmp[0]) {
|
|
if (wParam == IDD_CONNECTION && i == Connection_CurSelPos) {
|
|
SetDlgItemTextW(wnd[1].hWnd, IDC_STATUS, tmp);
|
|
}
|
|
AddColItem(tmp, 2, wnd[0].hWnd, IDC_OUTPUTSTATUS, i);
|
|
}
|
|
|
|
bool encoder_ok = false;
|
|
if (Enc) {
|
|
C_ENCODER *Encoder = Enc->GetEncoder();
|
|
if (Encoder) {
|
|
if (strcmp(Encoder->GetName(), "MP3 Encoder") == 0) {
|
|
encoder_ok = (libinst != NULL);
|
|
} else {
|
|
encoder_ok = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// update the playback buttons on the summary page
|
|
int mode = (Out->Config.Address[0] ? (Out->Config.Password[0] ?
|
|
(stationNameAllowed(Out->Config.Description) ?
|
|
(encoder_ok ? (states[i] == OUT_DISCONNECTED ? 0 :
|
|
states[i] == OUT_DISCONNECT ? 1 : states[i] == OUT_RECONNECT ? 7 : 2) : 6) : 5) : 4) : 3);
|
|
|
|
// used to limit the amount of processing which is done for this to keep updates to just what is needed
|
|
if (lastMode[i] == -1 || lastMode[i] != mode) {
|
|
int image_id[] = {IDI_PLAY, IDI_KILL, IDI_STOP, IDI_PLAY, IDI_PLAY, IDI_PLAY, IDI_PLAY, IDI_STOP};
|
|
|
|
// do checks to see if we need to update the error state of the tab items
|
|
int oldMode = lastMode[i];
|
|
lastMode[i] = mode;
|
|
|
|
RECT r = {0};
|
|
if (IsWindow(outTabWnd)) {
|
|
int index[] = {0, 0, 1, 2};
|
|
if (lastMode[i] >= 3 && lastMode[i] <= 6) {
|
|
TabCtrl_GetItemRect(outTabWnd, index[(lastMode[i] - 3)], &r);
|
|
InvalidateRect(outTabWnd, &r, 0);
|
|
}
|
|
|
|
if (oldMode >= 3 && oldMode <= 6) {
|
|
TabCtrl_GetItemRect(outTabWnd, index[(oldMode - 3)], &r);
|
|
InvalidateRect(outTabWnd, &r, 0);
|
|
}
|
|
}
|
|
|
|
TabCtrl_GetItemRect(GetDlgItem(hMainDLG, IDC_TAB), 1, &r);
|
|
InvalidateRect(GetDlgItem(hMainDLG, IDC_TAB), &r, 0);
|
|
|
|
// control the button states on the pages
|
|
EnableWindow(buttonWnd[i], lastEnable[i]);
|
|
|
|
EnableWindowDlgItem(wnd[1].hWnd, IDC_CONNECT, lastEnable[i]);
|
|
EnableWindowDlgItem(wnd[1].hWnd, IDC_AUTOCONNECT, lastEnable[i]);
|
|
|
|
SendMessage(buttonWnd[i], BM_SETIMAGE, IMAGE_ICON,
|
|
(LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(image_id[mode]),
|
|
IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
|
|
|
|
// control the 'connect' button to be disabled when no encoder / no password / invalid station name
|
|
if (i == Connection_CurSelPos) {
|
|
int button_id[] = {IDS_CONNECT, IDS_KILL, IDS_DISCONNECT, IDS_SET_SERVER, IDS_SET_PASSWORD, IDS_CHANGE_NAME, IDS_SET_ENCODER, IDS_ABORT};
|
|
SetDlgItemTextW(wnd[1].hWnd, IDC_CONNECT, LocalisedString(button_id[mode], NULL, 0));
|
|
LockOptionControls((states[i] == OUT_DISCONNECTED && Out->Handle != -1));
|
|
|
|
InvalidateRect(GetDlgItem(out_wnd[0].hWnd, IDC_ADDRESS_HEADER), 0, 0);
|
|
InvalidateRect(GetDlgItem(out_wnd[0].hWnd, IDC_PASSWORD_HEADER), 0, 0);
|
|
InvalidateRect(GetDlgItem(out_wnd[1].hWnd, IDC_NAME_HEADER), 0, 0);
|
|
InvalidateRect(GetDlgItem(out_wnd[2].hWnd, IDC_ENCODER_HEADER), 0, 0);
|
|
}
|
|
}
|
|
|
|
// update the title set
|
|
if (Out->AutoTitle) SetDlgItemTextW(out_wnd[0].hWnd, IDC_TITLE, title);
|
|
}
|
|
|
|
// preserve the last status message for filtering of the log output, etc
|
|
if (tmp[0]) wcsncpy(old_tmp[i], tmp, 1024);
|
|
}
|
|
} else if (wParam == 1337) { // stream title update
|
|
KillTimer(hDlg, wParam);
|
|
PostMessage(hMainDLG, WM_USER, 0, nowPlayingID);
|
|
} else if (wParam == 2234) { // fade (music)
|
|
if (InputDevice) {
|
|
clock_t MusCurTime = clock();
|
|
if (FadeStartTime == 0) {
|
|
FadeStartTime = MusCurTime;
|
|
}
|
|
MusCurTime -= FadeStartTime;
|
|
int micsrc = Input_Device_ID >= 1 ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
|
|
if (MusCurTime < (FadeTime * 100)) {
|
|
int musvol = FadeOut ? (MusVol * 10)+((((Mus2Vol - MusVol)*10) * MusCurTime) / (FadeTime * 100)) : (Mus2Vol * 10)+((((MusVol - Mus2Vol)*10) * MusCurTime) / (FadeTime * 100));
|
|
setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, musvol);
|
|
} else {
|
|
if (FadeOut) {
|
|
setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, Mus2Vol * 10);
|
|
} else {
|
|
setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, MusVol * 10);
|
|
}
|
|
FadeStartTime = 0;
|
|
KillTimer(hDlg, wParam);
|
|
// kill captured device
|
|
#ifdef CAPTURE_TESTING
|
|
if (!FadeOut) {// end_capture();
|
|
if (pPlayer != NULL) {
|
|
pPlayer->Stop();
|
|
delete pPlayer;
|
|
pPlayer = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
} else if (wParam == 2235) { // fade (capture device)
|
|
if (InputDevice) {
|
|
clock_t MicCurTime = clock();
|
|
if (MicFadeStartTime == 0) {
|
|
MicFadeStartTime = MicCurTime;
|
|
}
|
|
MicCurTime -= MicFadeStartTime;
|
|
int micsrc = Input_Device_ID >= 1 ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
|
|
if (MicCurTime < (MicFadeTime * 100)) {
|
|
int micvol = FadeOut ? ((MicVol * 10) * MicCurTime) / (MicFadeTime * 100) : (MicVol * 10)+(((MicVol*-10) * MicCurTime) / (MicFadeTime * 100));
|
|
setlev(micsrc, micvol);
|
|
} else {
|
|
if (FadeOut) {
|
|
setlev(micsrc, MicVol * 10);
|
|
} else {
|
|
setlev(micsrc, 0);
|
|
}
|
|
MicFadeStartTime = 0;
|
|
KillTimer(hDlg, wParam);
|
|
// kill captured device
|
|
#ifdef CAPTURE_TESTING
|
|
if (!FadeOut) {// end_capture();
|
|
if (pPlayer != NULL) {
|
|
pPlayer->Stop();
|
|
delete pPlayer;
|
|
pPlayer = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
} else if (wParam == 666) { // INI save timer
|
|
if (!ini_modified) break;
|
|
ini_modified = 0;
|
|
int i;
|
|
WritePrivateProfileInt("ofnidx", lastFilterIndex, 0, 0);
|
|
WritePrivateProfileInt("CurTab", curtab, 0, 0);
|
|
WritePrivateProfileInt("Connection_CurSelPos", Connection_CurSelPos, 0, 0);
|
|
WritePrivateProfileInt("Connection_CurTab", curouttab, 0, 0);
|
|
WritePrivateProfileInt("Encoder_CurSelPos", Encoder_CurSelPos, 0, 0);
|
|
WritePrivateProfileInt("Input_CurSelPos", Input_CurSelPos, 0, 0);
|
|
WritePrivateProfileInt("InputDevice", InputDevice, 0, 0);
|
|
WritePrivateProfileInt("MusicVolume", MusVol, 0, 0);
|
|
WritePrivateProfileInt("BGMusicVolume", Mus2Vol, 0, 0);
|
|
WritePrivateProfileInt("MicVolume", MicVol, 0, 0);
|
|
WritePrivateProfileInt("PTT_FT", FadeTime, 0, 0);
|
|
WritePrivateProfileInt("PTT_MicFT", MicFadeTime, 0, 0);
|
|
WritePrivateProfileInt("PTT_MicInput", Input_Device_ID, 0, 0);
|
|
WritePrivateProfileInt("PTT_Restore", Restore_PTT, 0, 0);
|
|
|
|
if (!IsIconic(hDlg)) {
|
|
WritePrivateProfileInt("WindowLeft", mainrect.left, 0, 0);
|
|
WritePrivateProfileInt("WindowTop", mainrect.top, 0, 0);
|
|
}
|
|
|
|
for (i = 0; i < NUM_ENCODERS; i++) {
|
|
int Type = 0;
|
|
char name[32];
|
|
StringCchPrintfA(name, ARRAYSIZE(name), "Encoder %u", i + 1);
|
|
|
|
if (WaitForSingleObject(Enc_mutex[i], INFINITE) == WAIT_OBJECT_0) {
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
|
|
int infosize = sizeof (T_ENCODER_MP3_INFO);
|
|
T_ENCODER_MP3_INFO *EncInfo = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
|
|
WritePrivateProfileInt("BitRate", EncInfo->output_bitRate, name, 0);
|
|
WritePrivateProfileInt("SampleRate", EncInfo->output_sampleRate, name, 0);
|
|
WritePrivateProfileInt("NumChannels", EncInfo->output_numChannels, name, 0);
|
|
WritePrivateProfileInt("QualityMode", EncInfo->QualityMode, name, 0);
|
|
Type = 1;
|
|
} else if (strcmp(Enc->GetName(), "Fraunhofer Encoder") == 0) { // FHG AAC
|
|
((C_ENCODER_NSV*) Enc)->FillConfFile(IniName, name);
|
|
Type = 2;
|
|
} else if (strcmp(Enc->GetName(), "AAC+ Encoder") == 0) { // AAC+
|
|
((C_ENCODER_NSV*) Enc)->FillConfFile(IniName, name);
|
|
Type = 2;
|
|
}
|
|
#ifdef USE_OGG
|
|
else if (strcmp(Enc->GetName(), "OGG Vorbis Encoder") == 0) { // OGG
|
|
((C_ENCODER_NSV*) Enc)->FillConfFile(IniName, name);
|
|
Type = 4;
|
|
}
|
|
#endif
|
|
}
|
|
ReleaseMutex(Enc_mutex[i]);
|
|
}
|
|
WritePrivateProfileInt("Type", Type, name, 0);
|
|
}
|
|
|
|
for (i = 0; i < NUM_OUTPUTS; i++) {
|
|
T_OUTPUT_CONFIG *Out = &Output[i].Config;
|
|
WritePrivateProfileString(Out->Name, "Address", Out->Address, IniName);
|
|
WritePrivateProfileInt("Port", Out->Port, Out->Name, 0);
|
|
WritePrivateProfileString(Out->Name, "UserID", Out->UserID, IniName);
|
|
WritePrivateProfileString(Out->Name, "StreamID", Out->StationID, IniName);
|
|
WritePrivateProfileString(Out->Name, "Password", Out->Password, IniName);
|
|
// disabled saving of this as it defeats the point of setting it on load
|
|
// (as it's otherwise over-written with the correct value from the server)
|
|
//WritePrivateProfileString(Out->Name, "Cipherkey", Out->cipherkey, IniName);
|
|
WritePrivateProfileString(Out->Name, "Description", Out->Description, IniName);
|
|
WritePrivateProfileString(Out->Name, "URL", Out->ServerURL, IniName);
|
|
WritePrivateProfileString(Out->Name, "Genre3", Out->Genre, IniName);
|
|
WritePrivateProfileString(Out->Name, "AIM", Out->AIM, IniName);
|
|
WritePrivateProfileString(Out->Name, "ICQ", Out->ICQ, IniName);
|
|
WritePrivateProfileString(Out->Name, "IRC", Out->IRC, IniName);
|
|
WritePrivateProfileInt("Public", Out->Public ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("AutoRecon", Out->AutoRecon ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("ReconTime", Out->ReconTime ? Out->ReconTime : 1, Out->Name, 0);
|
|
WritePrivateProfileInt("doTitleUpdate", Out->doTitleUpdate ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileString(Out->Name, "now", Out->Now, IniName);
|
|
WritePrivateProfileString(Out->Name, "next", Out->Next, IniName);
|
|
WritePrivateProfileInt("AutoTitle", Output[i].AutoTitle ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("AutoConnect", Output[i].AutoConnect ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("Logging", Output[i].Logging ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("LogCOS", Output[i].LogCOS ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("NextTitles", Output[i].NextTitles ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("Protocol", Output[i].Config.protocol, Out->Name, 0);
|
|
WritePrivateProfileInt("nextTrackLog", Output[i].nextTrackLog ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("nextTrackLogXML", Output[i].nextTrackLogXML ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileString(Out->Name, "nextTrackPath", ConvertToUTF8(Output[i].nextTrackPath), IniName);
|
|
WritePrivateProfileInt("useArt", Output[i].useArt ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("usePlayingArt", Output[i].usePlayingArt ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileInt("useStreamArt", Output[i].useStreamArt ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileString(Out->Name, "stationArtPath", ConvertToUTF8(Output[i].stationArtPath), IniName);
|
|
WritePrivateProfileInt("saveEncoded", Output[i].saveEncoded ? 1 : 0, Out->Name, 0);
|
|
WritePrivateProfileString(Out->Name, "saveEncodedPath", ConvertToUTF8(Output[i].saveEncodedPath), IniName);
|
|
WritePrivateProfileInt("Encoder", Output[i].Encoder, Out->Name, 0);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_SHOWWINDOW:
|
|
{
|
|
if (IsWindow(hDlg) && hDlg == hMainDLG && wnd[curtab].timer_freq != 0) {
|
|
KillTimer(hDlg, wnd[curtab].id);
|
|
SetTimer(hDlg, wnd[curtab].id, wnd[curtab].timer_freq, NULL);
|
|
} else if (IsWindow(hDlg) && hDlg == wnd[2].hWnd && in_wnd[InputDevice].timer_freq != 0) {
|
|
KillTimer(hDlg, in_wnd[InputDevice].id);
|
|
SetTimer(hDlg, in_wnd[InputDevice].id, in_wnd[InputDevice].timer_freq, NULL);
|
|
} else if (IsWindow(hDlg) && hDlg == wnd[1].hWnd && out_wnd[curouttab].timer_freq != 0) {
|
|
KillTimer(hDlg, out_wnd[curouttab].id);
|
|
SetTimer(hDlg, out_wnd[curouttab].id, out_wnd[curouttab].timer_freq, NULL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
//Handle Minimize to systray here
|
|
case WM_SIZE:
|
|
{
|
|
switch (wParam) {
|
|
case SIZE_RESTORED:
|
|
{
|
|
RemoveSystrayIcon(hDlg, SYSTRAY_ICY_ICON);
|
|
ShowWindow(hDlg, SW_SHOW);
|
|
}
|
|
break;
|
|
case SIZE_MINIMIZED:
|
|
{
|
|
AddSystrayIcon(hDlg, SYSTRAY_ICY_ICON, GetICYIcon(),
|
|
SYSTRAY_MAXIMIZE_MSG, szDescription2W);
|
|
ShowWindow(hDlg, SW_HIDE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_NOTITLES:
|
|
case IDC_AUTOTITLE:
|
|
case IDC_MANUALTITLE:
|
|
//case IDC_EXTERNALTITLE:
|
|
{
|
|
// TODO will need to change around some of the logic to cope with the external option
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
int lastAutoTitle = Out->AutoTitle;
|
|
Out->Config.doTitleUpdate = (LOWORD(wParam) != IDC_NOTITLES);
|
|
Out->AutoTitle = (LOWORD(wParam) == IDC_AUTOTITLE);
|
|
ini_modified = 1;
|
|
CheckRadioButton(hDlg, IDC_NOTITLES, IDC_MANUALTITLE, LOWORD(wParam));
|
|
UpdateTitleControls();
|
|
// if enabling then send the title update
|
|
if ((LOWORD(wParam) == IDC_AUTOTITLE) && lastAutoTitle != Out->AutoTitle) {
|
|
if (Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
std::vector<std::wstring> nextList;
|
|
nextList.clear();
|
|
Enc->UpdateTitle(0, nextList, Out->Handle, !!Out->NextTitles, true);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_SENDNEXTTITLES:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->NextTitles = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_VIEW_LOG:
|
|
{
|
|
wchar_t file[MAX_PATH];
|
|
ShellExecuteW(hMainDLG, L"open", GetSCLogFile(module.hwndParent, ARRAYSIZE(file), file, Connection_CurSelPos), 0, NULL, SW_SHOW);
|
|
}
|
|
break;
|
|
|
|
case IDC_CLEAR_LOG:
|
|
{
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
if (Out->Logging && logFiles[Connection_CurSelPos] != INVALID_HANDLE_VALUE) {
|
|
SetFilePointer(logFiles[Connection_CurSelPos], 0, NULL, FILE_BEGIN);
|
|
SetEndOfFile(logFiles[Connection_CurSelPos]);
|
|
} else {
|
|
wchar_t file[MAX_PATH];
|
|
HANDLE handle = CreateFileW(GetSCLogFile(module.hwndParent, ARRAYSIZE(file), file, Connection_CurSelPos),
|
|
GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
|
|
if (handle != INVALID_HANDLE_VALUE) {
|
|
SetFilePointer(handle, 0, NULL, FILE_BEGIN);
|
|
SetEndOfFile(handle);
|
|
CloseHandle(handle);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_LOGGING:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->Logging = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
if (Out->Logging) {
|
|
StartLogging(Connection_CurSelPos,Out->LogCOS);
|
|
} else {
|
|
StopLogging(Connection_CurSelPos);
|
|
}
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_CLEAR_ON_STARTUP:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->LogCOS = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_NEXT_TRACK_LOG:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->nextTrackLog = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
if (Out->nextTrackLog) {
|
|
StartNextTracks(Connection_CurSelPos, Out->nextTrackPath);
|
|
FillNextTracks(Connection_CurSelPos, !!Out->nextTrackLogXML);
|
|
} else {
|
|
StopNextTracks(Connection_CurSelPos);
|
|
}
|
|
EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_XML, Out->nextTrackLog);
|
|
EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, Out->nextTrackLog);
|
|
EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_BROWSE, Out->nextTrackLog);
|
|
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_NEXT_TRACK_XML:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->nextTrackLogXML = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
// reset the file if changing the state
|
|
if (Out->nextTrackLog) {
|
|
StopNextTracks(Connection_CurSelPos);
|
|
StartNextTracks(Connection_CurSelPos, Out->nextTrackPath);
|
|
FillNextTracks(Connection_CurSelPos, !!Out->nextTrackLogXML);
|
|
}
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_NEXT_TRACK_EDIT:
|
|
{
|
|
if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_NEXT_TRACK_BROWSE:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
wchar_t filepath[MAX_PATH] = {0},
|
|
file[MAX_PATH] = {0},
|
|
filter[64] = {0};
|
|
// strip path so we can set initial directory, etc
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
wcsncpy(filepath, Out->nextTrackPath, MAX_PATH);
|
|
wcsncpy(file, Out->nextTrackPath, MAX_PATH);
|
|
PathRemoveFileSpecW(filepath);
|
|
PathStripPathW(file);
|
|
|
|
OPENFILENAMEW ofn = {0};
|
|
ofn.lStructSize=sizeof(ofn);
|
|
ofn.hwndOwner=hMainDLG;
|
|
|
|
WASABI_API_LNGSTRINGW_BUF(IDS_ALL_FILES, filter, 64);
|
|
wchar_t * ptr=filter;
|
|
while(ptr && *ptr) {
|
|
if (*ptr==L'|') *ptr=0;
|
|
ptr++;
|
|
}
|
|
|
|
ofn.lpstrFilter=filter;
|
|
ofn.lpstrInitialDir=filepath;
|
|
ofn.lpstrFile=file;
|
|
ofn.nMaxFile=MAX_PATH;
|
|
ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
|
|
ofn.lpstrDefExt=L"log";
|
|
if (GetSaveFileNameW(&ofn))
|
|
{
|
|
// update things if the filename changed, etc
|
|
wcsncpy(Out->nextTrackPath, file, MAX_PATH);
|
|
SetDlgItemTextW(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, Out->nextTrackPath);
|
|
if (Out->nextTrackLog) {
|
|
StopNextTracks(Connection_CurSelPos);
|
|
StartNextTracks(Connection_CurSelPos, Out->nextTrackPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_SAVE_ENCODED_AUDIO:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->saveEncoded = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
// reset the file if changing the state
|
|
if (Out->saveEncoded) {
|
|
StartSaveEncoded(Connection_CurSelPos, Out->saveEncodedPath);
|
|
} else {
|
|
StopSaveEncoded(Connection_CurSelPos);
|
|
}
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_SAVE_ENCODED_AUDIO_EDIT:
|
|
{
|
|
if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_SAVE_ENCODED_AUDIO_BROWSE:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
wchar_t filepath[MAX_PATH] = {0},
|
|
file[MAX_PATH] = {0},
|
|
filter[64] = {0};
|
|
// strip path so we can set initial directory, etc
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
wcsncpy(filepath, Out->saveEncodedPath, MAX_PATH);
|
|
wcsncpy(file, Out->saveEncodedPath, MAX_PATH);
|
|
PathRemoveFileSpecW(filepath);
|
|
PathStripPathW(file);
|
|
|
|
OPENFILENAMEW ofn = {0};
|
|
ofn.lStructSize=sizeof(ofn);
|
|
ofn.hwndOwner=hMainDLG;
|
|
// sets the default extension if not specified to the type of the encoder being used
|
|
ofn.lpstrDefExt=(Enc_LastType[Connection_CurSelPos] != 0 ?
|
|
(!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/mpeg") ? L"mp3" :
|
|
(!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/ogg") ? L"ogg" : L"aac")) : L"");
|
|
|
|
StringCchPrintfW(filter, ARRAYSIZE(filter), WASABI_API_LNGSTRINGW(IDS_MPEG_AUDIO_FILES), ofn.lpstrDefExt, ofn.lpstrDefExt);
|
|
wchar_t* ptr=filter;
|
|
while(ptr && *ptr) {
|
|
if (*ptr==L'|') *ptr=0;
|
|
ptr++;
|
|
}
|
|
|
|
ofn.lpstrFilter=filter;
|
|
ofn.lpstrInitialDir=filepath;
|
|
ofn.lpstrFile=file;
|
|
ofn.nMaxFile=MAX_PATH;
|
|
ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
|
|
|
|
if (GetSaveFileNameW(&ofn))
|
|
{
|
|
// update things if the filename changed, etc
|
|
wcsncpy(Out->saveEncodedPath, file, MAX_PATH);
|
|
SetDlgItemTextW(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, Out->saveEncodedPath);
|
|
if (Out->saveEncoded) {
|
|
StopSaveEncoded(Connection_CurSelPos);
|
|
StartSaveEncoded(Connection_CurSelPos, Out->saveEncodedPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_USE_ART:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->useArt = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, Out->useArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_STREAM, Out->useArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, Out->useArt && Out->useStreamArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, Out->useArt && Out->useStreamArt);
|
|
|
|
// only update if we need to do so
|
|
UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, Out->useArt && Out->useStreamArt);
|
|
|
|
// this will update against what is read from the playing
|
|
UpdatePlayingAlbumArt(Out->Handle, Connection_CurSelPos, Out->useArt && Out->usePlayingArt);
|
|
|
|
Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
|
|
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_USE_ART_PLAYING:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->usePlayingArt = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
ini_modified = 1;
|
|
|
|
if(Out->usePlayingArt){
|
|
playingLength = 0;
|
|
playingType = 0x4101; // default in-case of issue
|
|
|
|
int w = 0, h = 0;
|
|
if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArt(lastFile, L"cover", &w, &h, &playingImage) == ALBUMART_SUCCESS) {
|
|
// make sure to free the original image after we've converted
|
|
ARGB32 *firstPlayingImage = playingImage;
|
|
playingImage = writeImg(playingImage, w, h, &playingLength, L"png");
|
|
WASABI_API_MEMMGR->sysFree(firstPlayingImage);
|
|
} else {
|
|
playingImage = 0;
|
|
}
|
|
}
|
|
|
|
UpdatePlayingAlbumArt(Out->Handle, Connection_CurSelPos, Out->useArt && Out->usePlayingArt);
|
|
Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_USE_ART_STREAM:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->useStreamArt = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
ini_modified = 1;
|
|
|
|
// skip this all if the mode is not enabled and only in SC2 mode
|
|
if ((LOBYTE(Out->Config.protocol) != 1) && Out->useArt) {
|
|
// this will only update generally on first connection
|
|
if (Out->useStreamArt && streamImage[Connection_CurSelPos] == (ARGB32 *)-1) {
|
|
UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, !!Out->useStreamArt);
|
|
}
|
|
}
|
|
|
|
if (UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, !!Out->useStreamArt)) {
|
|
Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
|
|
}
|
|
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, Out->useStreamArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, Out->useStreamArt);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_ART_EDIT:
|
|
{
|
|
if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_ART_BROWSE:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
wchar_t filepath[MAX_PATH] = {0},
|
|
file[MAX_PATH] = {0};
|
|
// strip path so we can set initial directory, etc
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
wcsncpy(filepath, Out->stationArtPath, MAX_PATH);
|
|
wcsncpy(file, Out->stationArtPath, MAX_PATH);
|
|
PathRemoveFileSpecW(filepath);
|
|
PathStripPathW(file);
|
|
|
|
OPENFILENAMEW ofn = {0};
|
|
ofn.lStructSize=sizeof(ofn);
|
|
ofn.hwndOwner=hMainDLG;
|
|
ofn.lpstrInitialDir=filepath;
|
|
ofn.lpstrFile=file;
|
|
ofn.nMaxFile=MAX_PATH;
|
|
ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
|
|
ofn.lpstrDefExt=L"png";
|
|
ofn.nFilterIndex=lastFilterIndex;
|
|
|
|
static int tests_run = 0;
|
|
static wchar_t filter[1024] = {0}, *sff = filter;
|
|
|
|
if (!tests_run) {
|
|
tests_run = 1;
|
|
FOURCC imgload = svc_imageLoader::getServiceType();
|
|
int n = WASABI_API_SVC->service_getNumServices(imgload);
|
|
for (int i=0; i<n; i++) {
|
|
waServiceFactory *sf = WASABI_API_SVC->service_enumService(imgload, i);
|
|
if (sf) {
|
|
svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
|
|
if (l) {
|
|
static int tests_idx[4] = {0, 1, 2, 3};
|
|
size_t size = 1024;
|
|
int j = 0, tests_str[] = {IDS_JPEG_FILE, IDS_PNG_FILE, IDS_BMP_FILE, IDS_GIF_FILE};
|
|
wchar_t *tests[] = {L"*.jpg", L"*.png", L"*.bmp", L"*.gif"};
|
|
for (int i = 0; i < ARRAYSIZE(tests); i++) {
|
|
if (l->isMine(tests[i])) {
|
|
tests_idx[j] = i;
|
|
j++;
|
|
int len = 0;
|
|
LocalisedString(tests_str[i], sff, size);
|
|
size-=(len = wcslen(sff)+1);
|
|
sff+=len;
|
|
wcsncpy(sff, (!i ? L"*.jpg;*.jpeg" : tests[i]), size);
|
|
size-=(len = wcslen(sff)+1);
|
|
sff+=len;
|
|
}
|
|
}
|
|
sf->releaseInterface(l);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ofn.lpstrFilter = filter;
|
|
|
|
if (GetOpenFileNameW(&ofn))
|
|
{
|
|
// update things if the filename changed, etc
|
|
wcsncpy(Out->stationArtPath, file, MAX_PATH);
|
|
SetDlgItemTextW(out_wnd[4].hWnd, IDC_ART_EDIT, Out->stationArtPath);
|
|
|
|
if (UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, !!Out->useStreamArt)) {
|
|
Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
|
|
}
|
|
}
|
|
lastFilterIndex = ofn.nFilterIndex;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_AUTOCONNECT:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
Output[Connection_CurSelPos].AutoConnect = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
if (Output[Connection_CurSelPos].Encoder) {
|
|
if (WaitForSingleObject(Enc_mutex[Output[Connection_CurSelPos].Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[Output[Connection_CurSelPos].Encoder].UpdateOutput(Output[Connection_CurSelPos].Handle);
|
|
ReleaseMutex(Enc_mutex[Output[Connection_CurSelPos].Encoder]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_RECONNECT:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
Output[Connection_CurSelPos].Config.AutoRecon = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
if (Output[Connection_CurSelPos].Encoder) {
|
|
if (WaitForSingleObject(Enc_mutex[Output[Connection_CurSelPos].Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[Output[Connection_CurSelPos].Encoder].UpdateOutput(Output[Connection_CurSelPos].Handle);
|
|
ReleaseMutex(Enc_mutex[Output[Connection_CurSelPos].Encoder]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_PROTOCOL:
|
|
{
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
|
|
int cur_sel = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0),
|
|
protocol = SendMessage((HWND) lParam, CB_GETITEMDATA, cur_sel, 0);
|
|
|
|
Out->Config.protocol = MAKEWORD(protocol, !protocol);
|
|
|
|
// force a refresh on selection change
|
|
lastMode[Connection_CurSelPos] = -1;
|
|
|
|
// jkey: disable or enable userid stationid based on protocol.
|
|
if (Output[Connection_CurSelPos].Encoder) {
|
|
if (WaitForSingleObject(Enc_mutex[Output[Connection_CurSelPos].Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[Output[Connection_CurSelPos].Encoder].UpdateOutput(Output[Connection_CurSelPos].Handle);
|
|
ReleaseMutex(Enc_mutex[Output[Connection_CurSelPos].Encoder]);
|
|
}
|
|
}
|
|
//shoutcast 2 else 1 enable aim,icq,irc
|
|
EnableWindowDlgItem(hDlg, IDC_STATIONID, (LOBYTE(Output[Connection_CurSelPos].Config.protocol) == 1));
|
|
UpdateTitleControls();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_CONNECT:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
SHOUTCAST_OUTPUT *Enc = Out->Encoder != -1 ? &Encoder[Out->Encoder] : NULL;
|
|
if (Enc && Out->Handle != -1) {
|
|
int state = Enc->GetState(Out->Handle);
|
|
if (state == OUT_DISCONNECTED) { // disconnected... connect now
|
|
Enc->ConnectOutput(Out->Handle);
|
|
} else { // connected... disconnect now
|
|
Enc->DisconnectOutput(Out->Handle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_DEVBOX:
|
|
{
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
Input_Device_ID = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_LOCK:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
int checked = SendMessage((HWND) lParam, BM_GETCHECK, -1, -1) == BST_CHECKED;
|
|
EnableWindowDlgItem(hDlg, IDC_PTT, !checked);
|
|
SendDlgItemMessage(hDlg, IDC_PTT, BM_SETSTATE, checked ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
KillTimer(hMainDLG, 2234);
|
|
KillTimer(hMainDLG, 2235);
|
|
if ((MicFadeStartTime != 0 || FadeStartTime != 0) && FadeOut != checked) {
|
|
clock_t myTime = clock();
|
|
if (FadeStartTime != 0) FadeStartTime = myTime - ((FadeTime * 100)-(myTime - FadeStartTime));
|
|
if (MicFadeStartTime != 0) MicFadeStartTime = myTime - ((MicFadeTime * 100)-(myTime - MicFadeStartTime));
|
|
}
|
|
if(!ptt_load && Restore_PTT || ptt_load) {
|
|
FadeOut = checked;
|
|
SetTimer(hMainDLG, 2234, 10, NULL); // fade out
|
|
SetTimer(hMainDLG, 2235, 10, NULL); // fade out
|
|
} else {
|
|
SetDeviceName();
|
|
}
|
|
ptt_load = 1;
|
|
//if (FadeOut) do_capture();
|
|
#ifdef CAPTURE_TESTING
|
|
if (FadeOut) {
|
|
if (!pPlayer) {
|
|
pPlayer = new Player(hMainDLG);
|
|
}
|
|
if (!pCallbacks) {
|
|
pCallbacks = new CPlayerCallbacks();
|
|
}
|
|
pPlayer->SetPlayerCallbacks(pCallbacks);
|
|
pPlayer->RefreshDeviceList(eRender);
|
|
pPlayer->RefreshDeviceList(eCapture);
|
|
pPlayer->SelectDefaultDevice(eRender, eConsole);
|
|
pPlayer->SelectDefaultDevice(eCapture, eConsole);
|
|
pPlayer->SelectDeviceFromList(eCapture, 0);
|
|
//pPlayer->SelectDeviceFromList(eRender, 2);
|
|
if (pPlayer->Play(eCaptureEndpoint) == FALSE) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_LOCK_MODE:
|
|
{
|
|
HMENU hmenu = CreatePopupMenu();
|
|
RECT r;
|
|
GetWindowRect((HWND)lParam, &r);
|
|
|
|
MENUITEMINFOW i = {sizeof(i), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING,
|
|
Restore_PTT ? MFS_CHECKED : 0, 1337};
|
|
i.dwTypeData = LocalisedString(IDS_PTT_ON_STARTUP, NULL, 0);
|
|
InsertMenuItemW(hmenu, 0, TRUE, &i);
|
|
if (TrackPopupMenu(hmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, r.left, r.bottom, 0, (HWND)lParam, NULL) == 1337) {
|
|
Restore_PTT = !Restore_PTT;
|
|
}
|
|
DestroyMenu(hmenu);
|
|
}
|
|
break;
|
|
|
|
case IDC_REFRESH_DEVICES:
|
|
{
|
|
if (IsVistaUp()) {
|
|
SendDlgItemMessage(inWin,IDC_DEVBOX, CB_RESETCONTENT, 0, 0);
|
|
SetDeviceName();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_MIXER:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
// open vista / win7 or win2k / xp recording panel
|
|
// (more sensible esp. for vista / win7)
|
|
if (IsVistaUp()) {
|
|
ShellExecuteW(hMainDLG, L"open", L"control.exe", L"mmsys.cpl,,1", NULL, SW_SHOW);
|
|
} else {
|
|
ShellExecuteW(hMainDLG, L"open", L"sndvol32.exe", L"", NULL, SW_SHOW);
|
|
ShellExecuteW(hMainDLG, L"open", L"sndvol32.exe", L"/r", NULL, SW_SHOW);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OUTPUTLIST:
|
|
{
|
|
if (HIWORD(wParam) == LBN_SELCHANGE) {
|
|
Connection_CurSelPos = SendMessage((HWND) lParam, LB_GETCURSEL, 0, 0);
|
|
|
|
// force a refresh on selection change
|
|
lastMode[Connection_CurSelPos] = -1;
|
|
|
|
// do checks to see if we need to update the error state of the tab items
|
|
if (IsWindow(outTabWnd)) {
|
|
RECT r = {0};
|
|
for (int i = 0; i < MAX_OUTWNDS; i++) {
|
|
TabCtrl_GetItemRect(outTabWnd, i, &r);
|
|
InvalidateRect(outTabWnd, &r, 0);
|
|
}
|
|
|
|
TabCtrl_GetItemRect(GetDlgItem(hMainDLG, IDC_TAB), 1, &r);
|
|
InvalidateRect(GetDlgItem(hMainDLG, IDC_TAB), &r, 0);
|
|
}
|
|
|
|
T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
|
|
MY_T_OUTPUT * OutEnc = &Output[Connection_CurSelPos];
|
|
int sc2mode = (LOBYTE(Out->protocol) != 1);
|
|
// Output page 1
|
|
SendDlgItemMessage(out_wnd[0].hWnd, IDC_ADDRESS, EM_SETLIMITTEXT, ARRAYSIZE(Out->Address) - 1, 0);
|
|
SetDlgItemText(out_wnd[0].hWnd, IDC_ADDRESS, Out->Address);
|
|
SendDlgItemMessage(out_wnd[0].hWnd, IDC_STATIONID, EM_SETLIMITTEXT, 10, 0);
|
|
SetDlgItemText(out_wnd[0].hWnd, IDC_STATIONID, Out->StationID);
|
|
SendDlgItemMessage(out_wnd[0].hWnd, IDC_USERID, EM_SETLIMITTEXT, ARRAYSIZE(Out->UserID) - 1, 0);
|
|
SetDlgItemText(out_wnd[0].hWnd, IDC_USERID, Out->UserID);
|
|
SetDlgItemInt(out_wnd[0].hWnd, IDC_PORT, Out->Port, 0);
|
|
SendDlgItemMessage(out_wnd[0].hWnd, IDC_PASSWORD, EM_SETLIMITTEXT, ARRAYSIZE(Out->Password) - 1, 0);
|
|
SetDlgItemText(out_wnd[0].hWnd, IDC_PASSWORD, Out->Password);
|
|
int encval = OutEnc->Encoder;
|
|
SendDlgItemMessage(out_wnd[0].hWnd, IDC_RECONNECT, BM_SETCHECK, Out->AutoRecon ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK, OutEnc->AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
|
|
SetDlgItemInt(out_wnd[0].hWnd, IDC_TIMEOUT, Out->ReconTime, 0);
|
|
|
|
EnableWindowDlgItem(out_wnd[0].hWnd, IDC_STATIONID, sc2mode);
|
|
SendDlgItemMessage(out_wnd[0].hWnd, IDC_PROTOCOL, CB_SETCURSEL, (HIBYTE(Out->protocol) ? 0 : (sc2mode ? 1 : 2)), 0);
|
|
|
|
|
|
// Output page 2
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_PUBLIC, BM_SETCHECK, Out->Public ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_DESCRIPTION, EM_SETLIMITTEXT, ARRAYSIZE(Out->Description) - 1, 0);
|
|
SetDlgItemText(out_wnd[1].hWnd, IDC_DESCRIPTION, Out->Description);
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_SERVERURL, EM_SETLIMITTEXT, ARRAYSIZE(Out->ServerURL) - 1, 0);
|
|
SetDlgItemText(out_wnd[1].hWnd, IDC_SERVERURL, Out->ServerURL);
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_GENRE, EM_SETLIMITTEXT, ARRAYSIZE(Out->Genre) - 1, 0);
|
|
SetDlgItemText(out_wnd[1].hWnd, IDC_GENRE, Out->Genre);
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_AIM, EM_SETLIMITTEXT, ARRAYSIZE(Out->AIM) - 1, 0);
|
|
SetDlgItemText(out_wnd[1].hWnd, IDC_AIM, Out->AIM);
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_ICQ, EM_SETLIMITTEXT, ARRAYSIZE(Out->ICQ) - 1, 0);
|
|
SetDlgItemText(out_wnd[1].hWnd, IDC_ICQ, Out->ICQ);
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_IRC, EM_SETLIMITTEXT, ARRAYSIZE(Out->IRC) - 1, 0);
|
|
SetDlgItemText(out_wnd[1].hWnd, IDC_IRC, Out->IRC);
|
|
|
|
SendDlgItemMessage(out_wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK, OutEnc->AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
|
|
// setup the handling of the encoder saving options
|
|
SendDlgItemMessage(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, EM_SETLIMITTEXT, ARRAYSIZE(OutEnc->stationArtPath) - 1, 0);
|
|
SetDlgItemTextW(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, OutEnc->saveEncodedPath);
|
|
SendDlgItemMessage(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO, BM_SETCHECK, OutEnc->saveEncoded ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
|
|
// setup the handling of the titles options
|
|
SendDlgItemMessage(out_wnd[3].hWnd, IDC_TITLE, EM_SETLIMITTEXT, ARRAYSIZE(Out->Now) - 1, 0);
|
|
SetDlgItemText(out_wnd[3].hWnd, IDC_TITLE, Out->Now);
|
|
SendDlgItemMessage(out_wnd[3].hWnd, IDC_NEXT, EM_SETLIMITTEXT, ARRAYSIZE(Out->Next) - 1, 0);
|
|
SetDlgItemText(out_wnd[3].hWnd, IDC_NEXT, Out->Next);
|
|
CheckRadioButton(out_wnd[3].hWnd, IDC_NOTITLES, IDC_MANUALTITLE, (Out->doTitleUpdate ? (OutEnc->AutoTitle ? IDC_AUTOTITLE : IDC_MANUALTITLE) : IDC_NOTITLES));
|
|
SendDlgItemMessage(out_wnd[3].hWnd, IDC_SENDNEXTTITLES, BM_SETCHECK, OutEnc->NextTitles ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
UpdateTitleControls();
|
|
|
|
// setup the handling of the artwork options
|
|
SendDlgItemMessage(out_wnd[4].hWnd, IDC_ART_EDIT, EM_SETLIMITTEXT, ARRAYSIZE(OutEnc->stationArtPath) - 1, 0);
|
|
SetDlgItemTextW(out_wnd[4].hWnd, IDC_ART_EDIT, OutEnc->stationArtPath);
|
|
SendDlgItemMessage(out_wnd[4].hWnd, IDC_USE_ART, BM_SETCHECK, OutEnc->useArt ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, BM_SETCHECK, OutEnc->usePlayingArt ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(out_wnd[4].hWnd, IDC_USE_ART_STREAM, BM_SETCHECK, OutEnc->useStreamArt ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, OutEnc->useArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_STREAM, OutEnc->useArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, OutEnc->useArt && OutEnc->useStreamArt);
|
|
EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, OutEnc->useArt && OutEnc->useStreamArt);
|
|
UpdateArtworkMessage();
|
|
|
|
// setup the handling of the next track logging option
|
|
SendDlgItemMessage(out_wnd[5].hWnd, IDC_LOGGING, BM_SETCHECK, OutEnc->Logging ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(out_wnd[5].hWnd, IDC_CLEAR_ON_STARTUP, BM_SETCHECK, OutEnc->LogCOS ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
|
|
SendDlgItemMessage(out_wnd[5].hWnd, IDC_NEXT_TRACK_LOG, BM_SETCHECK, OutEnc->nextTrackLog ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(out_wnd[5].hWnd, IDC_NEXT_TRACK_XML, BM_SETCHECK, OutEnc->nextTrackLogXML ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, EM_SETLIMITTEXT, ARRAYSIZE(OutEnc->nextTrackPath) - 1, 0);
|
|
SetDlgItemTextW(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, OutEnc->nextTrackPath);
|
|
EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_XML, OutEnc->nextTrackLog);
|
|
EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, OutEnc->nextTrackLog);
|
|
EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_BROWSE, OutEnc->nextTrackLog);
|
|
|
|
// this is sent to the encoders tab so it will update the selection for the current instance
|
|
// note: this is a change in build 009 to remove the prior listbox and reduce ui inconsistency
|
|
SendMessage(out_wnd[2].hWnd, WM_COMMAND, MAKEWPARAM(IDC_ENCODERLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(wnd[2].hWnd, IDC_ENCODERLIST));
|
|
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_INPUTSETUP:
|
|
{
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
|
|
Crossfader->SetChannels(LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].nch);
|
|
Crossfader->SetSampleRate(LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].srate);
|
|
ReleaseMutex(cf_mutex);
|
|
}
|
|
|
|
int attrib = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
|
|
if (attrib != Input_CurSelPos) {
|
|
SuspendThread(hthread);
|
|
Soundcard.Close();
|
|
if (InputDevice == 1) {
|
|
Input_CurSelPos = attrib;
|
|
}
|
|
for (int i = 0; i < NUM_ENCODERS; i++) {
|
|
if (WaitForSingleObject(Enc_mutex[i], INFINITE) == WAIT_OBJECT_0) {
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
int infosize = sizeof (T_EncoderIOVals);
|
|
T_EncoderIOVals *encset = (T_EncoderIOVals *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) {
|
|
T_EncoderIOVals *EncSettings = (T_EncoderIOVals *) malloc(infosize);
|
|
memcpy(EncSettings, encset, infosize);
|
|
|
|
if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
|
|
((T_ENCODER_MP3_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_MP3_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
} else if (strcmp(Enc->GetName(), "Fraunhofer Encoder") == 0) {
|
|
((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
} else if (strcmp(Enc->GetName(), "AAC+ Encoder") == 0) {
|
|
((T_ENCODER_AACP_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_AACP_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
}
|
|
#ifdef USE_OGG
|
|
else if (strcmp(Enc->GetName(), "OGG Vorbis Encoder") == 0) {
|
|
((T_ENCODER_OGG_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_OGG_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
}
|
|
#endif // USE_OGG
|
|
Enc->ChangeSettings(EncSettings);
|
|
free(EncSettings);
|
|
}
|
|
}
|
|
ReleaseMutex(Enc_mutex[i]);
|
|
}
|
|
}
|
|
Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
|
|
ResumeThread(hthread);
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_INPUT_WINAMP:
|
|
case IDC_INPUT_SOUNDCARD:
|
|
{
|
|
// update the input mode from the summary page options
|
|
HWND inputCtrl = GetDlgItem(wnd[2].hWnd, IDC_INPUTDEVICE);
|
|
SendMessage(inputCtrl, CB_SETCURSEL, (LOWORD(wParam) - IDC_INPUT_WINAMP), 0);
|
|
SendMessage(wnd[2].hWnd, WM_COMMAND, MAKEWPARAM(IDC_INPUTDEVICE,CBN_SELCHANGE), (LPARAM)inputCtrl);
|
|
}
|
|
break;
|
|
|
|
case IDC_INPUTDEVICE:
|
|
{
|
|
if (HIWORD(wParam) == CBN_SELCHANGE) {
|
|
int this_device = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
|
|
if (InputDevice != this_device) {
|
|
SuspendThread(hthread);
|
|
Soundcard.Close();
|
|
InputDevice = this_device;
|
|
if (InputDevice == 0) { // winamp
|
|
SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MUSSLIDER));
|
|
SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MUS2SLIDER));
|
|
SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MICSLIDER));
|
|
SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_FADESLIDER));
|
|
SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MICFADESLIDER));
|
|
}
|
|
for (int i = 0; i < NUM_ENCODERS; i++) {
|
|
if (WaitForSingleObject(Enc_mutex[i], INFINITE) == WAIT_OBJECT_0) {
|
|
C_ENCODER *Enc = Encoder[i].GetEncoder();
|
|
if (Enc) {
|
|
int infosize = sizeof (T_EncoderIOVals);
|
|
T_EncoderIOVals *encset = (T_EncoderIOVals *) Enc->GetExtInfo(&infosize);
|
|
if (encset && infosize) {
|
|
T_EncoderIOVals *EncSettings = (T_EncoderIOVals *) malloc(infosize);
|
|
memcpy(EncSettings, encset, infosize);
|
|
|
|
if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
|
|
((T_ENCODER_MP3_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_MP3_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
} else if (strcmp(Enc->GetName(), "Fraunhofer Encoder") == 0) {
|
|
((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
} else if (strcmp(Enc->GetName(), "AAC+ Encoder") == 0) {
|
|
((T_ENCODER_AACP_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_AACP_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
}
|
|
#ifdef USE_OGG
|
|
else if (strcmp(Enc->GetName(), "OGG Vorbis Encoder") == 0) {
|
|
((T_ENCODER_OGG_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
|
|
((T_ENCODER_OGG_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
|
|
}
|
|
#endif // USE_OGG
|
|
Enc->ChangeSettings(EncSettings);
|
|
free(EncSettings);
|
|
}
|
|
}
|
|
ReleaseMutex(Enc_mutex[i]);
|
|
}
|
|
}
|
|
Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
|
|
|
|
DisplayDeviceName();
|
|
CheckRadioButton(wnd[0].hWnd, IDC_INPUT_WINAMP, IDC_INPUT_SOUNDCARD, (IDC_INPUT_WINAMP + InputDevice));
|
|
|
|
peak_vu_l = peak_vu_r = -90;
|
|
ResumeThread(hthread);
|
|
ini_modified = 1;
|
|
}
|
|
SendDlgItemMessage(hDlg, IDC_INPUTSETUP, CB_RESETCONTENT, 0, 0);
|
|
if (InputDevice == 1) {
|
|
wchar_t temp[128];
|
|
int num_input_items = ARRAYSIZE(LineInputAttribs);
|
|
for (int i = 0; i < num_input_items; i++) {
|
|
wchar_t tmp[32];
|
|
StringCchPrintfW(temp, ARRAYSIZE(temp), LocalisedString(IDS_X_HZ_X, tmp, 32), LineInputAttribs[i].srate, LocalisedString(LineInputAttribs[i].nch == 1 ? IDS_MONO : IDS_STEREO, NULL, 0));
|
|
SendDlgItemMessageW(hDlg, IDC_INPUTSETUP, CB_ADDSTRING, 0, (LPARAM) temp);
|
|
}
|
|
SendDlgItemMessage(hDlg, IDC_INPUTSETUP, CB_SETCURSEL, Input_CurSelPos, 0);
|
|
}
|
|
for (int i = 0; i < num_inwnds; i++) ShowWindow(in_wnd[i].hWnd, i == InputDevice && curtab == 2 ? SW_SHOW : SW_HIDE);
|
|
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_INPUTSETUP, CBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_INPUTSETUP));
|
|
ShowWindowDlgItem(hDlg, IDC_INPUTSETUPSTATIC, InputDevice == 1);
|
|
ShowWindowDlgItem(hDlg, IDC_INPUTSETUP, InputDevice == 1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// server box
|
|
case IDC_ADDRESS:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
|
|
GetWindowText((HWND) lParam, Out->Address, ARRAYSIZE(Out->Address));
|
|
ini_modified = 1;
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// stream ID box
|
|
case IDC_STATIONID:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
BOOL success = FALSE;
|
|
int value = GetDlgItemInt(hDlg, LOWORD(wParam), &success, TRUE);
|
|
T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
|
|
GetWindowText((HWND) lParam, Out->StationID, ARRAYSIZE(Out->StationID));
|
|
// check and set the default as required
|
|
if (!Out->StationID[0] || (success && value < 1 || !success && value == 0)) {
|
|
SetWindowTextW((HWND) lParam, L"1");
|
|
lstrcpyn(Out->StationID, "1", ARRAYSIZE(Out->StationID));
|
|
} else if (Out->StationID[0] && (success && value > 2147483647)) {
|
|
SetWindowTextW((HWND) lParam, L"2147483647");
|
|
lstrcpyn(Out->StationID, "2147483647", ARRAYSIZE(Out->StationID));
|
|
}
|
|
ini_modified = 1;
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_USERID:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
|
|
GetWindowText((HWND) lParam, Out->UserID, ARRAYSIZE(Out->UserID));
|
|
ini_modified = 1;
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// server port
|
|
case IDC_PORT:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
BOOL success = FALSE;
|
|
int value = GetDlgItemInt(hDlg, LOWORD(wParam), &success, TRUE);
|
|
T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
|
|
// check and set the default as required
|
|
if ((success && value < 1 || !success && value == 0)) {
|
|
SetWindowTextW((HWND) lParam, L"8000");
|
|
Out->Port = 8000;
|
|
} else if ((success && value > 65535)) {
|
|
SetWindowTextW((HWND) lParam, L"65535");
|
|
Out->Port = 65535;
|
|
} else {
|
|
Out->Port = value;
|
|
}
|
|
|
|
ini_modified = 1;
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// password
|
|
case IDC_PASSWORD:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
|
|
GetWindowText((HWND) lParam, Out->Password, ARRAYSIZE(Out->Password));
|
|
ini_modified = 1;
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_SEND:
|
|
{
|
|
EnableWindowDlgItem(hDlg, IDC_SEND, FALSE);
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
if (Out->Encoder != -1 && Out->Handle != -1) {
|
|
wchar_t title[1024] = {0}, next[1024] = {0};
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
GetWindowTextW(GetDlgItem(out_wnd[3].hWnd, IDC_TITLE), title, ARRAYSIZE(title));
|
|
GetWindowTextW(GetDlgItem(out_wnd[3].hWnd, IDC_NEXT), next, ARRAYSIZE(next));
|
|
ini_modified = 1;
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
std::vector<std::wstring> nextList;
|
|
std::vector<int> nextListIdx;
|
|
nextList.clear();
|
|
nextListIdx.clear();
|
|
if (((Out->AutoTitle == 1 && Out->NextTitles) || Out->AutoTitle == 0) && next[0]) {
|
|
nextList.push_back(next);
|
|
nextListIdx.push_back(-1);
|
|
}
|
|
|
|
if (Out->nextTrackLog) {
|
|
WriteNextTracks(Connection_CurSelPos, module.hwndParent, nextListIdx, nextList, !!Out->nextTrackLogXML);
|
|
}
|
|
|
|
// check if in v2 mode and have a next title specified so as to change the send flag
|
|
Enc->UpdateTitle(title, nextList, Out->Handle, !!nextList.size(), false);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_TITLE:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
int length = GetWindowTextLength((HWND)lParam);
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, (length > 0));
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT,
|
|
(length > 0 && (LOBYTE(Out->Config.protocol) != 1)));
|
|
|
|
char temp[sizeof(Out->Config.Now)];
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.Now) != 0) {
|
|
lstrcpyn(Out->Config.Now, temp, ARRAYSIZE(Out->Config.Now));
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_NEXT:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, TRUE);
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
|
|
char temp[sizeof(Out->Config.Next)];
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.Next) != 0) {
|
|
lstrcpyn(Out->Config.Next, temp, ARRAYSIZE(Out->Config.Next));
|
|
ini_modified = 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_TIMEOUT:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
char temp[128] = {0};
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
|
|
int rt = atoi(temp);
|
|
if (rt < 1) {
|
|
rt = 5;
|
|
SetDlgItemInt(out_wnd[0].hWnd, IDC_TIMEOUT, 5, 0);
|
|
}
|
|
|
|
if (Out->Config.ReconTime != rt) {
|
|
Out->Config.ReconTime = rt;
|
|
if (Out->Encoder) {
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Encoder[Out->Encoder].UpdateOutput(Out->Handle);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
ini_modified = 1;
|
|
}
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// these will reconnect the Output on edit
|
|
case IDC_PUBLIC:
|
|
{
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
Out->Config.Public = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
|
|
|
|
// force a refresh on selection change
|
|
lastMode[Connection_CurSelPos] = -1;
|
|
|
|
ini_modified = 1;
|
|
if (Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_GENRES:
|
|
{
|
|
// build up a menu to allow the user to select only supported genres for use with YP
|
|
if (HIWORD(wParam) == BN_CLICKED) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
HMENU hmenu = CreatePopupMenu(), submenu = 0;
|
|
RECT r;
|
|
GetWindowRect((HWND)lParam, &r);
|
|
|
|
for (unsigned int i = 0; i < ARRAYSIZE(genres); i++) {
|
|
MENUITEMINFO mii = {sizeof(mii), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING, 0, 1+i, 0, 0, 0, 0, 0, 0};
|
|
bool reAdd = false;
|
|
|
|
// fix up genres with & in it to work around menu accelerator display quirks
|
|
std::string str = genres[i].name;
|
|
if (str.find("&") != std::string::npos)
|
|
str.replace(str.find("&"),1,"&&");
|
|
mii.dwTypeData = (LPSTR)str.c_str();
|
|
|
|
if (genres[i].parent) {
|
|
if (genres[i].children) {
|
|
reAdd = true;
|
|
mii.fMask |= MIIM_SUBMENU;
|
|
submenu = mii.hSubMenu = CreatePopupMenu();
|
|
}
|
|
}
|
|
|
|
if (reAdd == false && !strcmpi(Out->Config.Genre, genres[i].name)) {
|
|
mii.fState = MFS_CHECKED;
|
|
}
|
|
|
|
InsertMenuItem((genres[i].parent ? hmenu : submenu), i, TRUE, &mii);
|
|
|
|
if (reAdd == true) {
|
|
mii.fMask -= MIIM_SUBMENU;
|
|
if (!strcmpi(Out->Config.Genre, genres[i].name)) {
|
|
mii.fState = MFS_CHECKED;
|
|
}
|
|
InsertMenuItem(submenu, i, TRUE, &mii);
|
|
}
|
|
}
|
|
|
|
int ret = TrackPopupMenu(hmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, r.left, r.bottom, 0, (HWND)hDlg, NULL);
|
|
if (ret > 0) {
|
|
int update = 0;
|
|
ret -= 1;
|
|
if (strcmp(genres[ret].name, Out->Config.Genre) != 0) {
|
|
update = 1;
|
|
SetDlgItemText(hDlg, IDC_GENRE, genres[ret].name);
|
|
lstrcpyn(Out->Config.Genre, genres[ret].name, ARRAYSIZE(Out->Config.Genre));
|
|
ini_modified = 1;
|
|
}
|
|
if (update && Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
}
|
|
|
|
DestroyMenu(hmenu);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_DESCRIPTION:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
char temp[sizeof (Out->Config.Description)];
|
|
int update = 0;
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.Description) != 0) {
|
|
update = 1;
|
|
lstrcpyn(Out->Config.Description, temp, ARRAYSIZE(Out->Config.Description));
|
|
ini_modified = 1;
|
|
}
|
|
if (update && Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_SERVERURL:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
char temp[sizeof (Out->Config.ServerURL)];
|
|
int update = 0;
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.ServerURL) != 0) {
|
|
update = 1;
|
|
lstrcpyn(Out->Config.ServerURL, temp, ARRAYSIZE(Out->Config.ServerURL));
|
|
ini_modified = 1;
|
|
}
|
|
if (update && Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_AIM:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
char temp[sizeof (Out->Config.AIM)];
|
|
int update = 0;
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.AIM) != 0) {
|
|
update = 1;
|
|
lstrcpyn(Out->Config.AIM, temp, ARRAYSIZE(Out->Config.AIM));
|
|
ini_modified = 1;
|
|
}
|
|
if (update && Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_ICQ:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
char temp[sizeof (Out->Config.ICQ)];
|
|
int update = 0;
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.ICQ) != 0) {
|
|
update = 1;
|
|
lstrcpyn(Out->Config.ICQ, temp, ARRAYSIZE(Out->Config.ICQ));
|
|
ini_modified = 1;
|
|
}
|
|
if (update && Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_IRC:
|
|
{
|
|
if (HIWORD(wParam) == EN_UPDATE) {
|
|
MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
|
|
char temp[sizeof (Out->Config.IRC)];
|
|
int update = 0;
|
|
GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
|
|
if (strcmp(temp, Out->Config.IRC) != 0) {
|
|
update = 1;
|
|
lstrcpyn(Out->Config.IRC, temp, ARRAYSIZE(Out->Config.IRC));
|
|
ini_modified = 1;
|
|
}
|
|
if (update && Out->Encoder != -1 && Out->Handle != -1) {
|
|
SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
|
|
if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
|
|
Enc->DisconnectOutput(Out->Handle, 1, 5);
|
|
ReleaseMutex(Enc_mutex[Out->Encoder]);
|
|
}
|
|
}
|
|
} else if (HIWORD(wParam) == EN_SETFOCUS) {
|
|
PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_CTLCOLORSTATIC:
|
|
{
|
|
// this is used to update the header text of the options which need to be checked if there is a config error...
|
|
int id = GetDlgCtrlID((HWND)lParam);
|
|
if (id == IDC_ADDRESS_HEADER || id == IDC_PASSWORD_HEADER || id == IDC_NAME_HEADER || id == IDC_ENCODER_HEADER) {
|
|
int header_id[] = {0, 0, 0, IDC_ADDRESS_HEADER, IDC_PASSWORD_HEADER, IDC_NAME_HEADER, IDC_ENCODER_HEADER, 0};
|
|
if (lastMode[Connection_CurSelPos] >= 3 && lastMode[Connection_CurSelPos] <= 6 &&
|
|
header_id[lastMode[Connection_CurSelPos]] == id) {
|
|
SetTextColor((HDC)wParam, RGB(255,0,0));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
LPNMHDR pnmh = (LPNMHDR) lParam;
|
|
switch (LOWORD(wParam)) {
|
|
case IDC_TAB:
|
|
if (pnmh->code == TCN_SELCHANGE) {
|
|
int i;
|
|
KillTimer(hDlg, wnd[curtab].id);
|
|
curtab = SendMessage(pnmh->hwndFrom, TCM_GETCURSEL, 0, 0);
|
|
|
|
// send this to update the tab just incase we're showing invalid items
|
|
InvalidateRect(pnmh->hwndFrom, 0, 0);
|
|
|
|
ini_modified = 1;
|
|
if (wnd[curtab].timer_freq != 0) SetTimer(hDlg, wnd[curtab].id, wnd[curtab].timer_freq, NULL);
|
|
for (i = 0; i < num_tabwnds; i++) ShowWindow(wnd[i].hWnd, curtab == i ? SW_SHOW : SW_HIDE);
|
|
for (i = 0; i < num_inwnds; i++) ShowWindow(in_wnd[i].hWnd, i == InputDevice && curtab == 2 ? SW_SHOW : SW_HIDE);
|
|
for (i = 0; i < num_outwnds; i++) ShowWindow(out_wnd[i].hWnd, i == curouttab && curtab == 1 ? SW_SHOW : SW_HIDE);
|
|
// update the summary details when going back to it
|
|
if (curtab == 0) {
|
|
UpdateSummaryDetails(ListView_GetNextItem(GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS), -1, LVNI_SELECTED));
|
|
} else if(curtab == 1) {
|
|
// force a refresh on selection change
|
|
lastMode[Connection_CurSelPos] = -1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_CONTAB:
|
|
if (pnmh->code == TCN_SELCHANGE) {
|
|
int i;
|
|
KillTimer(hDlg, out_wnd[curouttab].id);
|
|
curouttab = SendMessage(pnmh->hwndFrom, TCM_GETCURSEL, 0, 0);
|
|
|
|
// send this to update the tab just incase we're showing invalid items
|
|
InvalidateRect(pnmh->hwndFrom, 0, 0);
|
|
|
|
ini_modified = 1;
|
|
if (out_wnd[curouttab].timer_freq != 0) SetTimer(hDlg, out_wnd[curouttab].id, out_wnd[curouttab].timer_freq, NULL);
|
|
for (i = 0; i < num_outwnds; i++) ShowWindow(out_wnd[i].hWnd, i == curouttab ? SW_SHOW : SW_HIDE);
|
|
bool enable = (LOBYTE(Output[Connection_CurSelPos].Config.protocol) == 1);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_AIM, enable);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_IRC, enable);
|
|
EnableWindowDlgItem(out_wnd[1].hWnd, IDC_ICQ, enable);
|
|
}
|
|
break;
|
|
|
|
case IDC_METALIST:
|
|
if (pnmh->code == NM_DBLCLK) {
|
|
LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) lParam;
|
|
if (lpnmitem->iItem != -1 && WASABI_API_EXPLORERFINDFILE) {
|
|
wchar_t fn[MAX_PATH]= {0};
|
|
lstrcpynW(fn, lastFile, MAX_PATH);
|
|
if (!PathIsURLW(fn)) {
|
|
// this will attempt to find the path of the parent folder of the file selected
|
|
// as spc files in a rsn archive can display album art (with the compatibility
|
|
// wrapper) and so it should cope with such scenarios...
|
|
wchar_t *filews = fn + lstrlenW(fn) - 1;
|
|
while(filews && *filews && (*filews != L'.') && (filews != fn)){filews = CharPrevW(fn,filews);}
|
|
while(filews && *filews && (*filews != L',' && *filews != L':')){filews = CharNextW(filews);}
|
|
if (filews) *filews = 0;
|
|
|
|
filews = wcsstr(fn,L".rsn\\");
|
|
if(filews) {
|
|
*(filews+4) = 0;
|
|
}
|
|
|
|
WASABI_API_EXPLORERFINDFILE->AddFile(fn);
|
|
WASABI_API_EXPLORERFINDFILE->ShowFiles();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OUTPUTSTATUS:
|
|
// on double-click go to the output tab and select the output we used as the currently shown
|
|
if (pnmh->code == NM_DBLCLK) {
|
|
LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) lParam;
|
|
if (lpnmitem->iItem != -1 && lpnmitem->iSubItem != 0) {
|
|
// only change the viewed output mode if it is different, otherwise just switch tab
|
|
if (Connection_CurSelPos != lpnmitem->iItem) {
|
|
Connection_CurSelPos = lpnmitem->iItem;
|
|
|
|
// force a refresh on selection change
|
|
lastMode[Connection_CurSelPos] = -1;
|
|
|
|
SendDlgItemMessage(wnd[1].hWnd, IDC_OUTPUTLIST, LB_SETCURSEL, Connection_CurSelPos, 0);
|
|
SendMessage(wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_OUTPUTLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(wnd[1].hWnd, IDC_OUTPUTLIST));
|
|
SetFocus(GetDlgItem(wnd[1].hWnd, IDC_OUTPUTLIST));
|
|
}
|
|
SetTab(1, hMainDLG, IDC_TAB);
|
|
}
|
|
} else if (pnmh->code == LVN_ITEMCHANGED) {
|
|
// on single-click / keyboard change, show some information about the stream such as most, encoder, etc (makes the page useful)
|
|
LPNMLISTVIEW lpnmitem = (LPNMLISTVIEW) lParam;
|
|
if (lpnmitem->iItem != -1) {
|
|
UpdateSummaryDetails(lpnmitem->iItem);
|
|
}
|
|
} else if(pnmh->code == LVN_KEYDOWN) {
|
|
LPNMLVKEYDOWN pnkd = (LPNMLVKEYDOWN) lParam;
|
|
// toggle state in the output list via 'space'
|
|
if (pnkd->wVKey == VK_SPACE) {
|
|
int item = ListView_GetNextItem(GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS), -1, LVNI_SELECTED);
|
|
if (lastEnable[item]) {
|
|
int oldCurSelPos = Connection_CurSelPos;
|
|
Connection_CurSelPos = item;
|
|
SendMessage(wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_CONNECT, BN_CLICKED), (LPARAM)GetDlgItem(wnd[1].hWnd, IDC_CONNECT));
|
|
Connection_CurSelPos = oldCurSelPos;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_HSCROLL:
|
|
{
|
|
int curpos = SendMessage((HWND) lParam, TBM_GETPOS, 0, 0);
|
|
if (GetDlgItem(hDlg, IDC_MUSSLIDER) == (HWND) lParam) {
|
|
MusVol = curpos;
|
|
if (InputDevice == 1 && !FadeOut) setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, MusVol * 10);
|
|
wchar_t tmp[256] = {0};
|
|
if (curpos != 0) {
|
|
wchar_t temp[32] = {0};
|
|
int volume = (int) (20 * log10(curpos * 3276.));
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
|
|
} else {
|
|
LocalisedString(IDS_INF_DB, tmp, 256);
|
|
}
|
|
SetDlgItemTextW(hDlg, IDC_MUSLEV1_TEXT, tmp);
|
|
} else if (GetDlgItem(hDlg, IDC_MUS2SLIDER) == (HWND) lParam) {
|
|
Mus2Vol = curpos;
|
|
if (InputDevice == 1 && FadeOut) setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, Mus2Vol * 10);
|
|
wchar_t tmp[256] = {0};
|
|
if (curpos != 0) {
|
|
wchar_t temp[32] = {0};
|
|
int volume = (int) (20 * log10(curpos * 3276.));
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
|
|
} else {
|
|
LocalisedString(IDS_INF_DB, tmp, 256);
|
|
}
|
|
SetDlgItemTextW(hDlg, IDC_MUSLEV2_TEXT, tmp);
|
|
} else if (GetDlgItem(hDlg, IDC_MICSLIDER) == (HWND) lParam) {
|
|
MicVol = curpos;
|
|
int micsrc = Input_Device_ID >= 1 ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
|
|
// changed this so it will only change the capture device level if PTT is pressed
|
|
if (InputDevice == 1 && FadeOut) setlev(micsrc, MicVol *10);
|
|
wchar_t tmp[256] = {0};
|
|
if (curpos != 0) {
|
|
wchar_t temp[32] = {0};
|
|
int volume = (int) (20 * log10(curpos * 3276.));
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
|
|
} else {
|
|
LocalisedString(IDS_INF_DB, tmp, 256);
|
|
}
|
|
SetDlgItemTextW(hDlg, IDC_MICLEV_TEXT, tmp);
|
|
} else if (GetDlgItem(hDlg, IDC_FADESLIDER) == (HWND) lParam) {
|
|
FadeTime = curpos;
|
|
wchar_t tmp[256] = {0}, temp[32] = {0};
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_MS, temp, 32), curpos * 100);
|
|
SetDlgItemTextW(hDlg, IDC_FADETIME_TEXT, tmp);
|
|
} else if (GetDlgItem(hDlg, IDC_MICFADESLIDER) == (HWND) lParam) {
|
|
MicFadeTime = curpos;
|
|
wchar_t tmp[256] = {0}, temp[32] = {0};
|
|
StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_MS, temp, 32), curpos * 100);
|
|
SetDlgItemTextW(hDlg, IDC_MICFADETIME_TEXT, tmp);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (FALSE != DirectMouseWheel_ProcessDialogMessage(hDlg, uMsg, wParam, lParam)) {
|
|
return TRUE;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CALLBACK CallWndProc(int nCode, WPARAM wParam, LPARAM lParam) {
|
|
if (nCode == HC_ACTION) {
|
|
LPCWPSTRUCT msg = (LPCWPSTRUCT)lParam;
|
|
// catch the new file playing message and update the cached metadata
|
|
if (msg->message == WM_WA_IPC) {
|
|
if (msg->lParam == IPC_PLAYING_FILEW) {
|
|
DWORD diff = GetTickCount();
|
|
was_paused = 0;
|
|
play_duration = 0;
|
|
play_diff = diff;
|
|
was_playing = 1;
|
|
if (wcsnicmp(lastFile, (wchar_t*)msg->wParam, MAX_PATH)) {
|
|
PostMessage(hMainDLG, WM_USER, 0, nowPlayingID);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (nowPlayingHook ? CallNextHookEx(nowPlayingHook, nCode, wParam, lParam) : 0);
|
|
}
|
|
|
|
LRESULT CALLBACK GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam) {
|
|
if (nCode == HC_ACTION) {
|
|
LPMSG msg = (LPMSG)lParam;
|
|
// catch the new file playing message and update the cached metadata
|
|
if (msg->message == WM_WA_IPC) {
|
|
if (msg->lParam == IPC_CB_MISC && msg->wParam == IPC_CB_MISC_STATUS) {
|
|
isplaying = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_ISPLAYING);
|
|
ProcessPlayingStatusUpdate();
|
|
} else if (msg->lParam == IPC_UPDTITLE) {
|
|
// attempt to keep a track of other title updates
|
|
// e.g. the re-streaming an already playing stream
|
|
wchar_t currentFile[MAX_PATH] = {0};
|
|
wchar_t *file=(wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC,
|
|
SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS),
|
|
IPC_GETPLAYLISTFILEW);
|
|
wcsncpy(currentFile, (file ? file : L""), MAX_PATH);
|
|
if (!wcsnicmp(currentFile, lastFile, MAX_PATH)) {
|
|
// do a 1 second delay since it's likely Winamp will send
|
|
// this a few times so we reset the timer everytime so we
|
|
// only do a proper title update once everything settles
|
|
KillTimer(hMainDLG, 1337);
|
|
SetTimer(hMainDLG, 1337, 1000, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (nowPlayingHook2 ? CallNextHookEx(nowPlayingHook2, nCode, wParam, lParam) : 0);
|
|
}
|
|
|
|
VOID CALLBACK TimerProc2(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
{
|
|
KillTimer(hwnd, idEvent);
|
|
SetForegroundWindow(hMainDLG);
|
|
}
|
|
|
|
void doConfig(HWND hwndParent) {
|
|
if (WASABI_API_SVC) {
|
|
if (!IsWindow(hMainDLG)) {
|
|
if (AGAVE_API_CONFIG) {
|
|
if (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"bits", 16) > 16) {
|
|
wchar_t title[128] = {0}, message[512] = {0};
|
|
StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_VersionW);
|
|
StringCchPrintfW(message, ARRAYSIZE(message), LocalisedString(IDS_24BIT_MODE_DETECTED, NULL, 0));
|
|
MessageBoxW(module.hwndParent, message, title, MB_ICONWARNING);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// using this to lessen issues with new track events with higher bitrates leading to failures
|
|
if (!nowPlayingHook) {
|
|
nowPlayingHook = SetWindowsHookExW(WH_CALLWNDPROC, CallWndProc, instance, GetCurrentThreadId());
|
|
}
|
|
if (!nowPlayingHook2) {
|
|
nowPlayingHook2 = SetWindowsHookExW(WH_GETMESSAGE, GetMsgProc, instance, GetCurrentThreadId());
|
|
}
|
|
if (nowPlayingID == -1) {
|
|
nowPlayingID = SendMessage(hwndParent, WM_WA_IPC, (WPARAM)&"dsp_sc_np", IPC_REGISTER_WINAMP_IPCMESSAGE);
|
|
}
|
|
|
|
HWND hwnd = LocalisedCreateDialog(instance, IDD_DIALOG, hwndParent, DialogFunc, IDD_DIALOG);
|
|
SetWindowPos(hwnd, HWND_TOP, mainrect.left, mainrect.top, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING);
|
|
SetTimer(hMainDLG, 999, 1, TimerProc2);
|
|
} else {
|
|
if (IsIconic(hMainDLG)) {
|
|
DialogFunc(hMainDLG, WM_SIZE, SIZE_RESTORED, 0);
|
|
ShowWindow(hMainDLG, SW_RESTORE);
|
|
ShowWindow(hMainDLG, SW_SHOW);
|
|
SetActiveWindow(hMainDLG);
|
|
}
|
|
SetForegroundWindow(hMainDLG);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID CALLBACK TimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
{
|
|
KillTimer(hwnd, idEvent);
|
|
doConfig(hwnd);
|
|
}
|
|
|
|
void Config(winampDSPModule *this_mod) {
|
|
// this will hold back opening the config dialog on loading until Winamp is in a ready state
|
|
// this resolves a partial fail to load i've often been seeing (plus from some users afaict)
|
|
SetTimer(this_mod->hwndParent, 999, 1, TimerProc);
|
|
}
|
|
|
|
int Init(winampDSPModule *this_mod) {
|
|
instance = this_mod->hDllInstance;
|
|
|
|
// this will hold back opening the config dialog on loading until Winamp is in a ready state
|
|
// this resolves a partial fail to load i've often been seeing (plus from some users afaict)
|
|
SetTimer(this_mod->hwndParent, 999, 1, TimerProc);
|
|
return 1;
|
|
}
|
|
|
|
int ModifySamples(winampDSPModule *this_mod, short int *samples, int numsamples, int bps, int nch, int srate) {
|
|
int numorig = numsamples;
|
|
|
|
//connect but only if we're meant to be i.e. there's at least 1 active output
|
|
if (InputDevice == 0) {
|
|
if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
|
|
// CT> Resample into the desired srate and nch if needed
|
|
// TODO check out the handling of this for 24-bit output
|
|
short cf_buf[256 * 1024] = {0};
|
|
if (srate != InputConfig.srate || nch != InputConfig.nch) {
|
|
char *s = (char *) samples;
|
|
int ns = numsamples * 2;
|
|
if (InputConfig.nch == 1) {
|
|
if (nch != 1 || bps != 16 || srate != (int) InputConfig.srate) {
|
|
if (nch == 2) {
|
|
int x;
|
|
int nns = MulDiv(numsamples, InputConfig.srate, srate);
|
|
int r = 0;
|
|
int dr = MulDiv(numsamples, 1 << 12, nns);
|
|
if (bps == 16)
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x] = samples[(r >> 12)*2] / 2 + samples[(r >> 12)*2 + 1] / 2;
|
|
r += dr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x] = ((((char *) samples)[(r >> 12)*2]^128) << 8) / 2 +
|
|
((((char *) samples)[(r >> 12)*2 + 1]^128) << 8) / 2;
|
|
r += dr;
|
|
}
|
|
}
|
|
ns = nns * 2;
|
|
} else {
|
|
int x;
|
|
int nns = MulDiv(numsamples, InputConfig.srate, srate);
|
|
int r = 0;
|
|
int dr = MulDiv(numsamples, 1 << 12, nns);
|
|
if (bps == 16)
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x] = samples[r >> 12];
|
|
r += dr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x] = (((char *) samples)[r >> 12]^128) << 8;
|
|
r += dr;
|
|
}
|
|
}
|
|
ns = nns * 2;
|
|
}
|
|
s = (char *) cf_buf;
|
|
}
|
|
} else {
|
|
if (nch != 2 || bps != 16 || srate != (int) InputConfig.srate) {
|
|
if (nch == 2) {
|
|
int x;
|
|
int nns = MulDiv(numsamples, InputConfig.srate, srate);
|
|
int r = 0;
|
|
int dr = MulDiv(numsamples, 1 << 12, nns);
|
|
if (bps == 16)
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x * 2] = samples[(r >> 12)*2];
|
|
cf_buf[x * 2 + 1] = samples[(r >> 12)*2 + 1];
|
|
r += dr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x * 2] = (((char *) samples)[(r >> 12)*2]^128) << 8;
|
|
cf_buf[x * 2 + 1] = (((char *) samples)[(r >> 12)*2 + 1]^128) << 8;
|
|
r += dr;
|
|
}
|
|
ns = nns * 4;
|
|
}
|
|
} else {
|
|
int x;
|
|
int nns = MulDiv(numsamples, InputConfig.srate, srate);
|
|
int r = 0;
|
|
int dr = MulDiv(numsamples, 1 << 12, nns);
|
|
if (bps == 16)
|
|
{
|
|
for (x = 0; x < nns; x++) {
|
|
cf_buf[x * 2] = cf_buf[x * 2 + 1] = samples[r >> 12];
|
|
r += dr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (x = 0; x < nns; x++)
|
|
{
|
|
cf_buf[x * 2] = cf_buf[x * 2 + 1] = (((char *) samples)[r >> 12]^128) << 8;
|
|
r += dr;
|
|
}
|
|
ns = nns * 4;
|
|
}
|
|
}
|
|
|
|
s = (char *) cf_buf;
|
|
}
|
|
else ns *= 2;
|
|
}
|
|
samples = (short *) s;
|
|
numsamples = ns / (InputConfig.nch * 2);
|
|
}
|
|
|
|
if (!VU.update) {
|
|
for (int j = 0; j < numsamples; j++) {
|
|
if (VU.vu_l < samples[j]) VU.vu_l = samples[j];
|
|
if (InputConfig.nch == 2) {
|
|
if (VU.vu_r < samples[j + 1]) VU.vu_r = samples[j + 1];
|
|
j++;
|
|
}
|
|
}
|
|
if (InputConfig.nch == 1) VU.vu_r = VU.vu_l;
|
|
VU.update = 1;
|
|
}
|
|
Crossfader->put(samples, numsamples);
|
|
ReleaseMutex(cf_mutex);
|
|
}
|
|
}
|
|
return numorig;
|
|
}
|
|
|
|
|
|
void Quit(winampDSPModule *this_mod) {
|
|
doQuit();
|
|
} |