winamp/Src/Plugins/General/gen_ff/wa2core.cpp

931 lines
20 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
#include <precomp.h>
#include "wa2core.h"
#include "wa2frontend.h"
#include "../winamp/wa_ipc.h"
#include "wa2pledit.h"
#include "../nu/AutoWide.h"
#include "gen.h"
#include "../nu/ns_wc.h"
#include "../Agave/Language/api_language.h"
#include "../Winamp/in2.h"
#include "resource.h"
#include "../nu/AutoChar.h"
#include <shlwapi.h>
// {72409F84-BAF1-4448-8211-D84A30A1591A}
static const GUID eqConfigGroupGUID =
{ 0x72409f84, 0xbaf1, 0x4448, { 0x82, 0x11, 0xd8, 0x4a, 0x30, 0xa1, 0x59, 0x1a } };
// -----------------------------------------------------------------------------------------------------------------
// Core implementation for wa2
// -----------------------------------------------------------------------------------------------------------------
#define TIMER_POLL 0x8971
Core *g_Core = NULL;
api_core *g_core = NULL;
int g_coreref = 0;
// this is called by the library when api->core_create is called
api_core *createCustomCoreApi()
{
g_coreref++;
if (g_core == NULL) { g_Core = new Core(); g_core = g_Core; }
return g_core;
}
// this is called when api->core_destroy is called
void destroyCustomCoreApi(api_core *core)
{
if (--g_coreref == 0)
{
delete g_Core;
g_Core = NULL;
g_core = NULL;
}
}
Core::Core()
{
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(Agave::AgaveConfigGUID);
if (sf)
config = (Agave::api_config *)sf->getInterface();
m_lastpeentry = -1;
m_laststatus = -1;
m_lastpos = -1;
m_lastvol = -1;
m_lastpan = -1;
m_lasttitle = L"";
m_lastsamplerate = -1;
m_lastchan = -1;
m_lastbitrate = -1;
for (int i = 0;i < 10;i++)
m_lasteqband[i] = 0xdead;
m_lasteq = -1;
m_lasteqauto = -1;
m_lasteqpreamp = -1;
m_lastfreqband = -1;
// timerclient_setTimer(TIMER_POLL, 250);
gotCallback(IPC_CB_MISC_TITLE, 1);
gotCallback(IPC_CB_MISC_VOLUME, 1);
gotCallback(IPC_CB_MISC_STATUS, 1);
gotCallback(IPC_CB_MISC_EQ, 1);
gotCallback(IPC_CB_MISC_INFO, 1);
gotCallback(IPC_CB_MISC_TITLE_RATING, 1);
}
Core::~Core()
{
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(Agave::AgaveConfigGUID);
if (sf)
sf->releaseInterface(config);
//timerclient_killTimer(TIMER_POLL);
}
void Core::addCallback(CoreCallback *cb)
{
if (cb == NULL) return ;
if (callbacks.haveItem(cb)) return ;
callbacks.addItem(cb);
cb->ccb_notify(CoreCallback::REGISTER);
}
void Core::delCallback(CoreCallback *cb)
{
if (cb == NULL) return ;
if (callbacks.haveItem(cb))
{
cb->ccb_notify(CoreCallback::DEREGISTER);
callbacks.removeItem(cb);
}
}
void Core::sendCoreCallback(int message, int param1, int param2)
{
ReentryFilter filter(&rf, message);
int l = callbacks.getNumItems();
for (int i = 0; i < l;i++)
callbacks[i]->ccb_notify(message, param1, param2);
}
int Core::getStatus()
{
return m_laststatus;
}
void Core::gotCallback(int wParam, int forcecb)
{
if(wParam == IPC_CB_MISC_TITLE_RATING){
forcecb = 1;
}
switch (wParam)
{
case IPC_CB_MISC_TITLE:
case IPC_CB_MISC_TITLE_RATING:
{
// check for title change
wa2.invalidateCache();
StringW cur_title=wa2.GetCurrentTitle();
if (cur_title.isempty())
cur_title = L"";
StringW cur_file = wa2.GetCurrentFile();
if (!m_lastfile.iscaseequal(cur_file) || forcecb)
{
m_lastfile.swap(cur_file);
sendCoreCallback(CoreCallback::URLCHANGE, (intptr_t)m_lastfile.getValue());
}
if (!m_lasttitle.iscaseequal(cur_title) || forcecb)
{
m_lasttitle.swap(cur_title);
//Martin> i dunno why we send a INFOCHANGE Callback here, but if we want to send this
// callback try to deliver the correct data
//sendCoreCallback((forcecb==2?CoreCallback::INFOCHANGE:CoreCallback::TITLECHANGE),
// (int)m_lasttitle.getValue(),(wParam == IPC_CB_MISC_TITLE_RATING));
if (forcecb==2) // this has led to INFOCHANGE Callback
{
sendCoreCallback(CoreCallback::INFOCHANGE, (intptr_t)getSongInfoText(), (wParam == IPC_CB_MISC_TITLE_RATING));
}
sendCoreCallback(CoreCallback::TITLECHANGE, (intptr_t)m_lasttitle.getValue(), (wParam == IPC_CB_MISC_TITLE_RATING));
}
int plentry = wa2.getCurPlaylistEntry();
int curpeentry = plentry + 1;
if (curpeentry != m_lastpeentry)
{
Wa2PlaylistEditor::_onNewCurrentIndex(curpeentry);
m_lastpeentry = curpeentry;
}
}
break;
case IPC_CB_MISC_STATUS:
{
int cur_status;
int resume = 0;
if (wa2.isPaused()) cur_status = STATUS_PAUSE;
else if (wa2.isPlaying())
{
if (m_laststatus == STATUS_PAUSE)
resume = 1;
else
{
m_lastsamplerate = -1;
m_lastbitrate = -1;
m_lastchan = -1;
}
cur_status = STATUS_PLAY;
}
else cur_status = STATUS_STOP;
if (m_laststatus != cur_status || forcecb)
{
m_laststatus = cur_status;
switch (cur_status)
{
case STATUS_PLAY: sendCoreCallback(resume ? CoreCallback::UNPAUSED : CoreCallback::STARTED); break;
case STATUS_STOP:
{
m_lastsamplerate = 0;
m_lastchan = 0;
m_lastbitrate = 0;
sendCoreCallback(CoreCallback::STOPPED);
break;
}
case STATUS_PAUSE: sendCoreCallback(CoreCallback::PAUSED); break;
}
}
}
break;
case IPC_CB_MISC_VOLUME:
{
// check for volume change
int cur_vol = wa2.getVolume();
if (m_lastvol != cur_vol || forcecb)
{
m_lastvol = cur_vol;
sendCoreCallback(CoreCallback::VOLCHANGE, cur_vol);
}
int cur_pan = wa2.getPanning();
if (m_lastpan != cur_pan || forcecb)
{
m_lastpan = cur_pan;
sendCoreCallback(CoreCallback::PANCHANGE, cur_pan);
}
}
break;
case IPC_CB_MISC_EQ:
{
// check if the band frequencies changed (winamp vs ISO)
int new_freqband = config->GetInt(eqConfigGroupGUID, L"frequencies", 0);
if (m_lastfreqband != new_freqband)
{
bool sendCallback = m_lastfreqband != -1;
m_lastfreqband = new_freqband; // set before the callback so we don't run into any issues if the callback triggers another EQ change message
if (sendCallback)
sendCoreCallback(CoreCallback::EQFREQCHANGE, new_freqband, 0);
}
// check for eq change
for (int i = 0;i < 10;i++)
{
int cur_band = wa2.getEqData(WA2_EQDATA_FIRSTBAND + i);
if (cur_band == 63 - ((m_lasteqband[i] + 127) / 4)) cur_band = m_lasteqband[i];
else cur_band = (63 - cur_band) * 4 - 127;
if (m_lasteqband[i] != cur_band || forcecb)
{
m_lasteqband[i] = cur_band;
sendCoreCallback(CoreCallback::EQBANDCHANGE, i, cur_band);
}
}
int cur_eq = wa2.getEqData(WA2_EQDATA_ENABLED);
if (m_lasteq != cur_eq)
{
m_lasteq = cur_eq;
sendCoreCallback(CoreCallback::EQSTATUSCHANGE, cur_eq);
}
int cur_eqauto = wa2.getEqData(WA2_EQDATA_AUTO);
if (m_lasteqauto != cur_eqauto || forcecb)
{
m_lasteqauto = cur_eqauto;
sendCoreCallback(CoreCallback::EQAUTOCHANGE, cur_eqauto);
}
int cur_eqpreamp = wa2.getEqData(WA2_EQDATA_PREAMP);
if (cur_eqpreamp == 63 - ((cur_eqpreamp + 127) / 4)) { /*cur_eqpreamp = cur_eqpreamp;*/ }
else cur_eqpreamp = (63 - cur_eqpreamp) * 4 - 127;
if (m_lasteqpreamp != cur_eqpreamp || forcecb)
{
m_lasteqpreamp = cur_eqpreamp;
sendCoreCallback(CoreCallback::EQPREAMPCHANGE, cur_eqpreamp);
}
}
break;
case IPC_CB_MISC_INFO:
{
int realrate = wa2.getSamplerate();
int brate = wa2.getBitrate();
int ch = wa2.getChannels();
int any = 0;
if (realrate != m_lastsamplerate || forcecb)
{
m_lastsamplerate = realrate;
sendCoreCallback(CoreCallback::SAMPLERATECHANGE, realrate);
any = 1;
}
if (brate != m_lastbitrate || forcecb)
{
m_lastbitrate = brate;
sendCoreCallback(CoreCallback::BITRATECHANGE, m_lastbitrate);
any = 1;
}
if (ch != m_lastchan || forcecb)
{
m_lastchan = ch;
sendCoreCallback(CoreCallback::CHANNELSCHANGE, m_lastchan);
any = 1;
}
//DebugString("Got IPC_CB_MISC_INFO callback, numchans = %d, samplerate = %d, bitrate = %d\n", m_lastchan, m_lastsamplerate, m_lastbitrate);
if (any)
{
StringW txt = getSongInfoText();
sendCoreCallback(CoreCallback::INFOCHANGE, (intptr_t)txt.getValue());
}
break;
}
}
}
StringW infotext;
const wchar_t *Core::getSongInfoText()
{
infotext = L"";
int srate = wa2.getSamplerate();
int brate = wa2.getBitrate();
int ch = wa2.getChannels();
if (srate == 0 && brate == 0)
{
return L"";
}
infotext = StringPrintfW(L"%dkbps", brate);
if (ch == 1)
{
infotext += L" mono";
}
else if (ch == 2)
{
infotext += L" stereo";
}
else if (ch > 2)
{
infotext += StringPrintfW(L" %d Channels", ch);
}
infotext += StringPrintfW(L" %.1fkHz", (float)srate/1000.0f);
if (wa2.isPlayingVideo())
{
infotext.prepend(L"Video ");
}
return infotext;
}
StringW infotextTranslated;
const wchar_t *Core::getSongInfoTextTranslated()
{
infotextTranslated = L"";
int srate = wa2.getSamplerate();
int brate = wa2.getBitrate();
int ch = wa2.getChannels();
if (srate == 0 && brate == 0)
{
return L"";
}
infotextTranslated = StringPrintfW(L"%d%s", brate,WASABI_API_LNGSTRINGW(IDS_KBPS));
if (ch == 1)
{
infotextTranslated += WASABI_API_LNGSTRINGW(IDS_MONO);
}
else if (ch == 2)
{
infotextTranslated += WASABI_API_LNGSTRINGW(IDS_STEREO);
}
else if (ch > 2)
{
infotextTranslated += StringPrintfW(WASABI_API_LNGSTRINGW(IDS_X_CHANNELS), ch);
}
infotextTranslated += StringPrintfW(L" %.1f", (float)srate/1000.0f);
infotextTranslated += WASABI_API_LNGSTRINGW(IDS_KHZ);// (doing this in the StringPrintfW(..) above causes a crash even in a seperate buffer)
if (wa2.isPlayingVideo())
{
infotextTranslated.prepend(StringPrintfW(L"%s ",WASABI_API_LNGSTRINGW(IDS_VIDEO)));
}
return infotextTranslated;
}
void Core::userButton(int button)
{
int mod = Std::keyDown(VK_SHIFT) ? WA2_USERBUTTONMOD_SHIFT : (Std::keyDown(VK_SHIFT) ? WA2_USERBUTTONMOD_CTRL : WA2_USERBUTTONMOD_NONE);
switch (button)
{
case UserButton::PLAY: wa2.userButton(WA2_USERBUTTON_PLAY, mod); break;
case UserButton::STOP: wa2.userButton(WA2_USERBUTTON_STOP, mod); break;
case UserButton::PAUSE: wa2.userButton(WA2_USERBUTTON_PAUSE, mod); break;
case UserButton::NEXT: wa2.userButton(WA2_USERBUTTON_NEXT, mod); break;
case UserButton::PREV: wa2.userButton(WA2_USERBUTTON_PREV, mod); break;
}
}
void Core::setVolume(int vol)
{
wa2.setVolume(vol);
}
int Core::getVolume()
{
return wa2.getVolume();
}
void Core::setPosition(int ms)
{
wa2.seekTo(ms);
sendCoreCallback(CoreCallback::SEEKED, ms);
}
int Core::getPosition()
{
if (m_laststatus == STATUS_STOP) return -1;
return wa2.getPosition();
}
int Core::getLength()
{
if (m_laststatus == STATUS_STOP) return -1;
return wa2.getLength();
}
void Core::setPanning(int p)
{
if (p > 127) p = 127;
wa2.setPanning(p);
}
int Core::getPanning()
{
return wa2.getPanning();
}
void Core::setShuffle(int shuffle)
{
wa2.setShuffle(shuffle);
}
int Core::getShuffle()
{
return wa2.getShuffle();
}
void Core::setRepeat(int repeat)
{
static int myset = 0;
if (!myset)
{
myset = 1;
int manadv = 0;
int rep = 0;
if (repeat == 0)
{
rep = 0;
manadv = 0;
}
else if (repeat > 0)
{
rep = 1;
manadv = 0;
}
else if (repeat < 0)
{
rep = 1;
manadv = 1;
}
if (!!wa2.getRepeat() != !!rep) wa2.setRepeat(rep);
if (!!wa2.getManualPlaylistAdvance() != !!manadv) wa2.setManualPlaylistAdvance(manadv);
myset = 0;
}
}
int Core::getRepeat()
{
int manadv = wa2.getManualPlaylistAdvance();
int rep = wa2.getRepeat();
int _v = (rep && manadv) ? -1 : rep;
return _v;
}
int Core::getSamplerate(int wa2_getinfo)
{
return wa2.getInfo(WA2_GETINFO_SAMPLERATE);
}
int Core::getBitrate(int wa2_getinfo)
{
return wa2.getInfo(WA2_GETINFO_BITRATE);
}
int Core::getChannels(int wa2_getinfo)
{
return wa2.getInfo(WA2_GETINFO_CHANNELS);
}
int Core::getEqBand(int band)
{
// int v = 63-wa2.getEqData(WA2_EQDATA_FIRSTBAND+band) * 4 - 127;
// v = MIN(-127, v);
// v = MAX(127, v);
return m_lasteqband[band]; //(v);
}
void Core::setEqBand(int band, int val)
{
val = MIN(127, MAX( -127, val));
m_lasteqband[band] = val;
int v = 63 - ((val + 127) / 4);
v = MIN(63, v);
v = MAX(0, v);
wa2.setEqData(WA2_EQDATA_FIRSTBAND + band, v);
sendCoreCallback(CoreCallback::EQBANDCHANGE, band, val);
}
int Core::getEQStatus()
{
return wa2.getEqData(WA2_EQDATA_ENABLED);
}
void Core::setEQStatus(int enable)
{
wa2.setEqData(WA2_EQDATA_ENABLED, enable);
}
int Core::getEQAuto()
{
return wa2.getEqData(WA2_EQDATA_AUTO);
}
void Core::setEQAuto(int enable)
{
wa2.setEqData(WA2_EQDATA_AUTO, enable);
}
int Core::getEQPreamp()
{
// int v = 63-wa2.getEqData(WA2_EQDATA_PREAMP) * 4 - 127;
// v = MIN(-127, v);
// v = MAX(127, v);
return m_lasteqpreamp;
}
void Core::setEQPreamp(int val)
{
val = MIN(127, MAX( -127, val));
m_lasteqpreamp = val;
int v = 63 - ((val + 127) / 4);
v = MIN(63, v);
v = MAX(0, v);
wa2.setEqData(WA2_EQDATA_PREAMP, v);
sendCoreCallback(CoreCallback::EQPREAMPCHANGE, val);
}
const wchar_t *Core::getTitle()
{
return m_lasttitle; // faster to use our cached ver
// int plentry = wa2.getCurPlaylistEntry();
// if (plentry == -1) return NULL;
// return wa2.getTitle(plentry);
}
void Core::setTitle(const wchar_t * new_title)
{
StringW title = new_title;
if(title.isempty())
title = L"";
m_lasttitle = title;
}
const wchar_t *Core::getPlaystring()
{
m_playstring = wa2.GetCurrentFile();
if (m_playstring.getValue() == NULL) m_playstring = L"";
return m_playstring;
}
int Core::getCurPlaylistEntry()
{
return wa2.getCurPlaylistEntry();
}
// -----------------------------------------------------------------------------------------------------------------
// api_core implementation
// -----------------------------------------------------------------------------------------------------------------
// this pointer is set automagically by ApiInit
api_core *coreApi = NULL;
const wchar_t *Core::core_getSupportedExtensions()
{
return L"mp3\x0";
}
const wchar_t *Core::core_getExtSupportedExtensions()
{
return L"mp3\x0";
}
CoreToken Core::core_create()
{
return 0;
}
int Core::core_free(CoreToken core)
{
return 0;
}
int Core::core_setNextFile(CoreToken core, const wchar_t *playstring)
{
return 0;
}
int Core::core_getStatus(CoreToken core)
{
switch (getStatus())
{
case STATUS_STOP : return 0;
case STATUS_PLAY : return 1;
case STATUS_PAUSE : return -1;
}
return 0; // dunno, stopped i guess...
}
const wchar_t *Core::core_getCurrent(CoreToken core)
{
return getPlaystring();
}
int Core::core_getCurPlaybackNumber(CoreToken core)
{
return getCurPlaylistEntry();
}
int Core::core_getPosition(CoreToken core)
{
return getPosition();
}
int Core::core_getWritePosition(CoreToken core)
{
return getPosition();
}
int Core::core_setPosition(CoreToken core, int ms)
{
setPosition(ms);
return 1;
}
int Core::core_getLength(CoreToken core)
{
return getLength();
}
int Core::core_getPluginData(const wchar_t *playstring, const wchar_t *name, wchar_t *data, int data_len, int data_type)
{
return 0;
}
unsigned int Core::core_getVolume(CoreToken core)
{
return getVolume();
}
void Core::core_setVolume(CoreToken core, unsigned int vol)
{
setVolume(vol);
}
int Core::core_getPan(CoreToken core)
{
return getPanning();
}
void Core::core_setPan(CoreToken core, int val)
{
setPanning(val);
}
void Core::core_addCallback(CoreToken core, CoreCallback *cb)
{
addCallback(cb);
}
void Core::core_delCallback(CoreToken core, CoreCallback *cb)
{
delCallback(cb);
}
int Core::core_getVisData(CoreToken core, void *dataptr, int sizedataptr)
{
int ret = 75*2;
// added this to attempt to cope with some poor / old input plug-ins
// which keep cropping up in the plug-in crash reports from users...
try
{
// todo
if (wa2.export_sa_get)
{
if (sizedataptr >= (75*2 + 8))
wa2.export_sa_get((char *)dataptr);
else
{
char data[75*2 + 8];
char *p = wa2.export_sa_get(data);
if (p) memcpy(dataptr, p, min(2*75, sizedataptr));
}
}
else if (wa2.export_sa_get_deprecated)
{
char *p = wa2.export_sa_get_deprecated();
if (p) memcpy(dataptr, p, min(2*75, sizedataptr));
}
}
catch(...)
{
ret = 0;
}
return ret;
}
int Core::core_getLeftVuMeter(CoreToken core)
{
if (wa2.export_vu_get)
{
int vu = wa2.export_vu_get(0);
if (vu != -1)
return vu;
}
if (wa2.export_sa_get)
{
char data[75*2 + 8] = {0};
char *p = (char *)wa2.export_sa_get(data);
if (!p) return 0;
int m = 0;
for (int i = 75;i < 150;i++) // this is very gay but workish
m = max(abs(m), p[i]);
return MIN(255, m*16);
}
else if (wa2.export_sa_get_deprecated)
{
char *p = (char *)wa2.export_sa_get_deprecated();
if (!p) return 0;
int m = 0;
for (int i = 75;i < 150;i++) // this is very gay but workish
m = max(abs(m), p[i]);
return MIN(255, m*16);
}
else return 0;
}
int Core::core_getRightVuMeter(CoreToken core)
{
if (wa2.export_vu_get)
{
int vu = wa2.export_vu_get(1);
if (vu == -1)
vu = wa2.export_vu_get(0);
if (vu != -1)
return vu;
}
return core_getLeftVuMeter(core);
}
int Core::core_registerSequencer(CoreToken core, ItemSequencer *seq)
{
return 0;
}
int Core::core_deregisterSequencer(CoreToken core, ItemSequencer *seq)
{
return 0;
}
void Core::core_userButton(CoreToken core, int button)
{
userButton(button);
}
int Core::core_getEqStatus(CoreToken core)
{
return getEQStatus();
}
void Core::core_setEqStatus(CoreToken core, int enable)
{
setEQStatus(enable);
}
int Core::core_getEqPreamp(CoreToken core)
{
return getEQPreamp();
}
void Core::core_setEqPreamp(CoreToken core, int pre)
{
setEQPreamp(pre);
}
int Core::core_getEqBand(CoreToken core, int band)
{
return getEqBand(band);
}
void Core::core_setEqBand(CoreToken core, int band, int val)
{
setEqBand(band, val);
}
int Core::core_getEqAuto(CoreToken core)
{
return getEQAuto();
}
void Core::core_setEqAuto(CoreToken core, int enable)
{
setEQAuto(enable);
}
void Core::core_setCustomMsg(CoreToken core, const wchar_t *text)
{}
void Core::core_registerExtension(const wchar_t *extensions, const wchar_t *extension_name, const wchar_t *family)
{}
const wchar_t *Core::core_getDecoderName(const wchar_t *filename)
{
wchar_t fn[MAX_PATH+3] = {0};
WCSNPRINTF(fn, MAX_PATH, L"hi.%s", filename);
In_Module *player = (In_Module *)wa2.CanPlay(fn);
if (player)
{
// cope nicely with the 5.64+ input plug-ins with unicode descriptions
static wchar_t decoder_name[512];
int ver = ((player->version & ~IN_UNICODE) & ~IN_INIT_RET);
if (ver == IN_VER)
{
StringCchCopyW(decoder_name, 512, (wchar_t *)player->description);
}
else
{
MultiByteToWideCharSZ(CP_ACP, 0, player->description, -1, decoder_name, 512);
}
return decoder_name;
}
return NULL;
}
const wchar_t *Core::core_getExtensionFamily(const wchar_t *extension)
{
wchar_t fn[MAX_PATH] = {0};
WCSNPRINTF(fn, MAX_PATH, L"hi.%s", extension);
In_Module *player = (In_Module *)wa2.CanPlay(fn);
if (player)
{
/*
char *p = player->FileExtensions;
const wchar_t *realExt = PathFindExtensionW(fn);
if (realExt && *realExt)
realExt++;
AutoChar ext(realExt);
while (p && *p)
{
char *b = p;
char *c;
do
{
char d[20] = {0};
lstrcpyn(d, b, 15);
if ((c = strstr(b, ";")))
{
if ((c-b)<15)
d[c - b] = 0;
}
if (!_stricmp(ext, d))
{
p += lstrlen(p) + 1; // skip to the name
MultiByteToWideCharSZ(CP_ACP, 0, p, -1, family, 512);
return family;
}
b = c + 1;
}
while (c);
p += lstrlen(p) + 1;
if (!*p) break;
p += lstrlen(p) + 1;
}
*/
static wchar_t family[512];
MultiByteToWideCharSZ(CP_ACP, 0, player->description, -1, family, 512);
return family;
}
return NULL;
}
void Core::core_unregisterExtension(const wchar_t *extensions)
{}
const wchar_t *Core::core_getTitle(CoreToken core)
{
return getTitle();
}
void Core::core_setTitle(const wchar_t *new_title)
{
setTitle(new_title);
}
int Core::core_getRating()
{
return wa2.getCurTrackRating();
}
void Core::core_setRating(int newRating)
{
wa2.setCurTrackRating(newRating);
}