#include "stdafx.h"
#include "Chipcon Remote Control.h"
#include "WinampGen.h"
#include "WinampIpc.h"
static const GUID WINAMP_REMOTE_GUID = { 0xEFA3F566, 0x6E8C, 0x4CC2, { 0x93, 0xFB, 0x31, 0x3B, 0x1B, 0xA3, 0x4D, 0x9E } };
// Global variables
HANDLE hRemoteControlThread;
HANDLE hRemoteDisplayThread;
HANDLE hDeviceMonitorThread;
CudalPipe *pControlPipe;
CudalPipe *pDisplayPipe;
CudalDongle *pDongle;
BOOL quitAsap;
// Function prototypes
int waInit(void);
void waConfig(void);
void waQuit(void);
winampGeneralPurposePlugin plugin = {
GPPHDR_VER,
"Chipcon Remote Control", // Description
waInit, // Initialization function
waConfig, // Configuration function
waQuit // Deinitialization function
};
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
return TRUE;
}
DWORD WINAPI RemoteDisplayThread(LPVOID lpParameter) {
WINAMP_DISPLAY_DATA lastWaDispData;
WINAMP_DISPLAY_DATA waDispData;
int lastTime = -1;
BOOL forceRefresh;
memset(&lastWaDispData, 0x00, sizeof(WINAMP_DISPLAY_DATA));
// Bail out when Winamp tells us to, or die in sympathy for the other thread
while (!quitAsap && pControlPipe) {
// Initialize displayData
memset(&waDispData, 0x00, sizeof(WINAMP_DISPLAY_DATA));
// Get output time
int time = WA_GET_PLAY_TIME();
if (time != -1) {
waDispData.milliseconds = time % 1000;
waDispData.seconds = (time / 1000) % 60;
waDispData.minutes = time / (1000 * 60);
// Check output time for changes
if ((waDispData.milliseconds != lastWaDispData.milliseconds) ||
(waDispData.seconds != lastWaDispData.seconds) ||
(waDispData.minutes != lastWaDispData.minutes)) {
waDispData.refresh |= WDD_REFRESH_TIME_BM;
}
}
// Check the time for significant changes
if (time < lastTime) {
forceRefresh = TRUE;
} else if (time > (lastTime + SIGNIFICANT_TIME_DELTA)) {
forceRefresh = TRUE;
} else {
forceRefresh = FALSE;
}
lastTime = time;
// Get play state
waDispData.state = 0x00;
if (WA_IS_PLAYING()) {
waDispData.state |= WDD_STATE_PLAYING_BM;
} else if (WA_IS_PAUSED()) {
waDispData.state |= WDD_STATE_PAUSED_BM;
}
// Check player state for changes
if ((waDispData.state & (WDD_STATE_PLAYING_BM | WDD_STATE_PAUSED_BM)) !=
(lastWaDispData.state & (WDD_STATE_PLAYING_BM | WDD_STATE_PAUSED_BM))) {
waDispData.refresh |= WDD_REFRESH_PLAY_STATE_BM;
}
// Get shuffle state
if (WA_GET_SHUFFLE()) waDispData.state |= WDD_STATE_SHUFFLE_BM;
// Check shuffle state for changes
if ((waDispData.state & WDD_STATE_SHUFFLE_BM) != (lastWaDispData.state & WDD_STATE_SHUFFLE_BM)) {
waDispData.refresh |= WDD_REFRESH_SHUFFLE_STATE_BM;
}
// Get track title
int titleLength;
if (WA_GET_LIST_LENGTH()) {
char *pTitlePtr = WA_GET_LIST_TITLE(WA_GET_LIST_POS());
memcpy(waDispData.pTitle, pTitlePtr, min(sizeof(waDispData.pTitle), strlen(pTitlePtr)));
titleLength = strlen(pTitlePtr);
} else {
sprintf(waDispData.pTitle, "- No playlist -");
titleLength = strlen(waDispData.pTitle);
}
// Calculate the total length of the display data
waDispData.totalLength = sizeof(waDispData)
- sizeof(waDispData.pTitle)
+ titleLength;
// Check track title for changes
if ((waDispData.totalLength != lastWaDispData.totalLength) ||
(memcmp(waDispData.pTitle, lastWaDispData.pTitle, titleLength) != 0)) {
waDispData.refresh |= WDD_REFRESH_TITLE_BM;
}
// Send it if there are any relevant changes
if ((waDispData.refresh & (WDD_REFRESH_PLAY_STATE_BM | WDD_REFRESH_SHUFFLE_STATE_BM | WDD_REFRESH_TITLE_BM)) ||
(forceRefresh)) {
DWORD length = waDispData.totalLength;
switch (pDisplayPipe->WriteSync(&waDispData, &length, 100)) {
case USBIO_ERR_SUCCESS:
case USBIO_ERR_TIMEOUT:
// It's only a success if the transferred length is correct
if (length == waDispData.totalLength) break;
default:
// Fatal error (possibly disconnection)
goto error;
}
}
memcpy(&lastWaDispData, &waDispData, sizeof(WINAMP_DISPLAY_DATA));
Sleep(DISPLAY_INTERVAL);
}
error:
delete pDisplayPipe;
pDisplayPipe = NULL;
return 0;
}
DWORD WINAPI RemoteControlThread(LPVOID lpParameter) {
WINAMP_CONTROL_DATA controlData;
CudalAsyncInfo asyncInfo;
DWORD length;
// Start polling
if (!pControlPipe->ReadAsync(&asyncInfo, &controlData, sizeof(WINAMP_CONTROL_DATA))) {
goto error;
}
// Bail out when Winamp tells us to, or die in sympathy for the other thread
while (!quitAsap && pDisplayPipe) {
// Did we get anything?
switch (pControlPipe->WaitAsync(&asyncInfo, &length, 100)) {
case USBIO_ERR_SUCCESS:
// Make sure that we got it all...
if (length == 2) {
// When a command is received, perform the corresponding action
switch (controlData.command) {
case DONGLE_CMD_PREVIOUS_TRACK: WA_CMD_PREVIOUS_TRACK(); break;
case DONGLE_CMD_PLAY: WA_CMD_PLAY(); break;
case DONGLE_CMD_PAUSE: WA_CMD_PAUSE(); break;
case DONGLE_CMD_STOP: WA_CMD_STOP(); break;
case DONGLE_CMD_NEXT_TRACK: WA_CMD_NEXT_TRACK(); break;
case DONGLE_CMD_VOLUMEUP: WA_CMD_VOLUMEUP(); break;
case DONGLE_CMD_VOLUMEDOWN: WA_CMD_VOLUMEDOWN(); break;
case DONGLE_CMD_FFWD5S: WA_CMD_FFWD5S(); break;
case DONGLE_CMD_REW5S: WA_CMD_REW5S(); break;
case DONGLE_SET_REPEAT: WA_SET_REPEAT(controlData.value); break;
case DONGLE_SET_SHUFFLE: WA_SET_SHUFFLE(controlData.value); break;
case DONGLE_SET_VOLUME: WA_SET_VOLUME(controlData.value); break;
}
}
// Continue polling
if (!pControlPipe->ReadAsync(&asyncInfo, &controlData, sizeof(WINAMP_CONTROL_DATA))) {
goto error;
}
break;
case USBIO_ERR_TIMEOUT:
// A timeout does not have any effect
break;
default:
// Fatal error (possibly disconnection)
goto error;
}
}
error:
// Terminate the transfer
pControlPipe->AbortAll();
pControlPipe->WaitAsyncTermination(&asyncInfo);
// Delete the control pipe to tell the other threads that we're done
delete pControlPipe;
pControlPipe = NULL;
return 0;
}
DWORD WINAPI DongleMonitorThread(LPVOID lpParameter) {
DWORD dummy;
// This is sort of the main loop. Leave when the quit signal is given
while (!quitAsap) {
// If the pipes don't exist, then try to find a dongle to connect to
if (!pControlPipe && !pDisplayPipe) {
// Close the old thread handles
if (hRemoteControlThread) {
CloseHandle(hRemoteControlThread);
hRemoteControlThread = NULL;
}
if (hRemoteDisplayThread) {
CloseHandle(hRemoteDisplayThread);
hRemoteDisplayThread = NULL;
}
// Clean up after last rounds
if (pDongle) {
delete pDongle;
pDongle = NULL;
}
// Find the correct dongle type
CUDAL_DONGLE_INFO pDongleInfo[MAX_DONGLE_ENUM_COUNT];
int dongleCount = CudalDongle::EnumDongles(pDongleInfo, MAX_DONGLE_ENUM_COUNT, &WINAMP_REMOTE_GUID);
for (int n = 0; n < dongleCount; n++) {
if ((pDongleInfo[n].vendorId == CHIPCON_VID) &&
(pDongleInfo[n].productId == WINAMP_REMOTE_CONTROL_PID)) {
// If the dongle object could be created, then create the control and display pipes
if (pDongle = CudalDongle::CreateDongle(&pDongleInfo[n], 0, &WINAMP_REMOTE_GUID)) {
pDisplayPipe = pDongle->CreatePipe(REMOTE_DISPLAY_ENDPOINT, FALSE);
pControlPipe = pDongle->CreatePipe(REMOTE_CONTROL_ENDPOINT, TRUE);
// When both pipes have been created, the two data transfer threads can be started
if (pDisplayPipe && pControlPipe) {
hRemoteControlThread = CreateThread(NULL, 0, RemoteControlThread, NULL, 0, &dummy);
hRemoteDisplayThread = CreateThread(NULL, 0, RemoteDisplayThread, NULL, 0, &dummy);
n = dongleCount;//stop searching
// If not, then destroy everything
} else {
if (pDisplayPipe) { delete pDisplayPipe; pDisplayPipe = NULL; }
if (pControlPipe) { delete pControlPipe; pControlPipe = NULL; }
if (pDongle) { delete pDongle; pDongle = NULL; }
}
}
}
}
}
// Reduce activity
for (int s = 0; s < 10; s++) {
if (!quitAsap) {
Sleep(MONITOR_INTERVAL / 10);
}
}
}
// Wait for the other threads to quit before destroying the dongle object
if (hRemoteControlThread) {
WaitForSingleObject(hRemoteControlThread, 5000);
CloseHandle(hRemoteControlThread);
}
if (hRemoteDisplayThread) {
WaitForSingleObject(hRemoteDisplayThread, 5000);
CloseHandle(hRemoteDisplayThread);
}
if (pDongle) delete pDongle;
return 0;
}
int waInit(void) {
DWORD dummy;
// Reset relevant globals
hRemoteControlThread = 0;
hRemoteDisplayThread = 0;
pControlPipe = NULL;
pDisplayPipe = NULL;
pDongle = NULL;
quitAsap = FALSE;
// Start the monitoring thread, which discovers a dongle and initializes it
hDeviceMonitorThread = CreateThread(NULL, 0, DongleMonitorThread, NULL, 0, &dummy);
return 0;
}
void waConfig(void) {
MessageBox(plugin.hwndParent,
"This plug-in demonstrates the Chipcon USB Dongle Access Library\n"
"(CUDAL). Download \"winamp_remote.hex\" into a CC2510 on a\n"
"SmartRF04EB, and \"winamp_dongle.hex\" into the CC2511 dongle.\n"
"The plug-in will detect and attach to the first unused remote\n"
"control that it finds. The dongle safely be removed at any time\n"
"and re-connected later on.",
"Chipcon Remote Control",
MB_OK | MB_ICONINFORMATION);
}
void waQuit(void) {
quitAsap = TRUE;
WaitForSingleObject(hDeviceMonitorThread, INFINITE);
CloseHandle(hDeviceMonitorThread);
}
extern "C" {
__declspec(dllexport) winampGeneralPurposePlugin *winampGetGeneralPurposePlugin(void) {
return &plugin;
}
}
