/****************************************************************************
NAME
sinkFmRxEraseFreq
DESCRIPTION
erases the currently tuned frequency if it is stored in persistant store
RETURNS
nothing
*/
void sinkFmRxEraseFreq(uint16 freq)
{
fm_stored_freq *stored_freq = &theSink.conf2->sink_fm_data.fmStoredFreq;
uint8 index = FM_MAX_PRESET_STATIONS;
FM_DEBUG(("sinkFmRxEraseFreq \n"));
/*Get index where requested freq is stored*/
index = sinkFmGetIndex(stored_freq, freq);
/*If no free index available, storage is full, indicate to user*/
if (index < FM_MAX_PRESET_STATIONS)
{
FM_DEBUG(("Erased station %d at index %d \n", freq, index));
sinkFmUpdateAtIndex(index, INVALID_FREQ, stored_freq);
FM_DEBUG(("Station tuned to Freq %d erased \n", freq));
/* erase the stored frequency */
(void) ConfigStore(CONFIG_FM_FREQUENCY_STORE, stored_freq, sizeof(fm_stored_freq));
/*Display stored freq without a favourite sign, continue tuning until changed by user*/
sinkFmDisplayFreq(freq, FM_DEL_FAV_STATION);
}
}
/****************************************************************************
NAME
sinkFmRxPowerOff
DESCRIPTION
Poewrs off the FM hardware to save power and free memory used
RETURNS
nothing
*/
void sinkFmRxPowerOff(void)
{
FM_DEBUG(("sinkFmRxPowerOff \n"));
fmRxPowerOff();
/* store current frequency in ps */
configManagerWriteSessionData () ;
}
/****************************************************************************
NAME
sinkFmRxUpdateVolume
DESCRIPTION
Sets the volume output of the FM reciever chip itself, codec volume control
is via the FM audio plugin
RETURNS
nothing
*/
void sinkFmRxUpdateVolume(uint8 vol)
{
FM_DEBUG(("sinkFmRxUpdateVolume \n"));
/* FM receiver internal volume is scaled 0 to 64, default volume * 4 gives
a volume level comparable to other audio sources */
fmRxUpdateVolume(vol * 4);
}
/****************************************************************************
NAME
sinkFmRxTuneToStore
DESCRIPTION
tunes the FM receiver to the stored frequency in increasing order
If currently tuned freq is the first stored freq, then the second entry in the stored list will be played.
If the second entry is zero, the third entry will be tuned to.
If no station is stored, request is ignored.
RETURNS
nothing
*/
void sinkFmRxTuneToStore(uint16 current_freq)
{
uint16 tune_freq = INVALID_FREQ;
fm_stored_freq *stored_freq = &theSink.conf2->sink_fm_data.fmStoredFreq;
FM_DEBUG(("sinkFmRxTuneToStore current freq %d \n", current_freq));
/*Check if currently tuned freq is stored, then tune to the next entry*/
tune_freq = sinkFmGetNextStoredFreq(current_freq, stored_freq);
FM_DEBUG(("Tune to freq %d \n", tune_freq));
/* ensure valid frequency before attempting to tune to it */
if(tune_freq!=INVALID_FREQ)
fmRxTuneFrequency(tune_freq);
else
MessageSend ( &theSink.task, EventSysError, 0) ;
}
/****************************************************************************
NAME
sinkFmRxAudioDisconnect
DESCRIPTION
Disconnects the FM audio via the audio library/FM audio plugin
RETURNS
nothing
*/
void sinkFmRxAudioDisconnect(void)
{
FM_DEBUG(("sinkFmRxAudioDisconnect \n"));
/* ensure FM is on and FM audio currently being routed to speaker */
if ((theSink.conf2->sink_fm_data.fmRxOn) && sinkFmAudioSinkMatch(theSink.routed_audio))
{
FM_DEBUG(("FM audio disconnected \n"));
/* reset routed audio */
theSink.routed_audio = 0;
/* disconnect FM audio via audio library */
AudioDisconnect();
/* Update limbo state */
if (stateManagerGetState() == deviceLimbo )
stateManagerUpdateLimboState();
}
}
/****************************************************************************
NAME
sinkFmRxStoreFreq
DESCRIPTION
Stores the currently tuned frequency to persistant store, if storage space available.
User must delete a station to make space for newer stations
RETURNS
nothing
*/
void sinkFmRxStoreFreq(uint16 freq)
{
fm_stored_freq *stored_freq = &theSink.conf2->sink_fm_data.fmStoredFreq;
uint8 index = FM_MAX_PRESET_STATIONS;
FM_DEBUG(("sinkFmRxStoreFreq freq %d\n", freq));
if (freq != INVALID_FREQ)
{
/*If requested freq already present in PSKEY, ignore the request*/
if (sinkFmGetIndex(stored_freq, freq) < FM_MAX_PRESET_STATIONS)
{
FM_DEBUG(("Freq already stored - Do nothing\n"));
}
else
{
/*Get free index*/
index = sinkFmGetIndex(stored_freq, INVALID_FREQ);
if (index < FM_MAX_PRESET_STATIONS)
{
FM_DEBUG(("Stored station %d at index %d \n", freq, index));
sinkFmUpdateAtIndex(index, freq, stored_freq);
/* store requested frequency */
(void) ConfigStore(CONFIG_FM_FREQUENCY_STORE, stored_freq, sizeof(fm_stored_freq));
/*Display stored freq with a favourite sign*/
sinkFmDisplayFreq(freq, FM_ADD_FAV_STATION);
}
else /*If no free index available, storage is full, indicate to user*/
{
#ifdef ENABLE_DISPLAY
displayShowText(DISPLAYSTR_FM_STORAGE_FULL, strlen(DISPLAYSTR_FM_STORAGE_FULL), 1, DISPLAY_TEXT_SCROLL_SCROLL, 500, 2000, FALSE, 5);
#endif
FM_DEBUG(("FM storage full. Please delete a stored station. \n"));
}
}
}
}
/****************************************************************************
NAME
sinkFmGetIndex
DESCRIPTION
utility function to get a index for requested operation
In case of STORE, returns a free index.
In case of ERASE, returns index corresponding to the requested freq
RETURNS
index in PS key
*/
uint8 sinkFmGetIndex(fm_stored_freq *stored_freq, uint16 freq)
{
uint8 index;
for (index=0;index<FM_MAX_PRESET_STATIONS;index++)
{
if (stored_freq->freq[index] == freq)
{
break;
}
}
FM_DEBUG(("sinkFmGetIndex (%d)\n", index));
return index;
}
static QFontEngine *loadWin(const QFontPrivate *d, int script, const QFontDef &req)
{
// list of families to try
QStringList family_list = familyList(req);
const char *stylehint = styleHint(d->request);
if (stylehint)
family_list << QLatin1String(stylehint);
// append the default fallback font for the specified script
// family_list << ... ; ###########
// add the default family
QString defaultFamily = QApplication::font().family();
if (! family_list.contains(defaultFamily))
family_list << defaultFamily;
// add QFont::defaultFamily() to the list, for compatibility with
// previous versions
family_list << QApplication::font().defaultFamily();
// null family means find the first font matching the specified script
family_list << QString();
QtFontDesc desc;
QFontEngine *fe = 0;
QList<int> blacklistedFamilies;
while (!fe) {
for (int i = 0; i < family_list.size(); ++i) {
QString family, foundry;
parseFontName(family_list.at(i), foundry, family);
FM_DEBUG("loadWin: >>>>>>>>>>>>>>trying to match '%s'", family.toLatin1().data());
QT_PREPEND_NAMESPACE(match)(script, req, family, foundry, -1, &desc, blacklistedFamilies);
if (desc.family)
break;
}
if (!desc.family)
break;
fe = loadEngine(script, req, d->hdc, d->dpi, d->rawMode, &desc, family_list);
if (!fe)
blacklistedFamilies.append(desc.familyIndex);
}
return fe;
}
/****************************************************************************
NAME
sinkFmInit
DESCRIPTION
initialises the fm hardware, mode is passed to determine which part of the FM
system is to be configured
RETURNS
nothing
*/
void sinkFmInit(fm_mode mode)
{
FM_DEBUG(("sinkFmInit \n"));
switch (mode)
{
case FM_ENABLE_RX:
fmRxInit(FM_PLUGIN_RX, &theSink.task, theSink.conf2->sink_fm_data.fm_plugin_data);
break;
case FM_ENABLE_TX:
break;
case FM_ENABLE_RX_TX:
break;
default:
break;
}
}
/****************************************************************************
NAME
sinkFmDisplayFreq
DESCRIPTION
utility function for displaying FM station on LCD
A favourite station will be indicated by appending a (*)
RETURNS
nothing
*/
void sinkFmDisplayFreq(uint16 freq, fm_display_type type )
{
#if ENABLE_DISPLAY
char display_freq[FM_DISPLAY_STR_LEN];
uint8 len;
if (type == FM_ADD_FAV_STATION)
{
/*Add a star to a favourite station for the user to identify*/
len = sprintf(display_freq, "%d.%d FM*", (freq/100), (freq%100)/10);
}
else
{
len = sprintf(display_freq, "%d.%d FM", (freq/100), (freq%100)/10);
}
FM_DEBUG(("FM display freq: %s (len = %d)\n", display_freq, len));
displayShowText((char*) display_freq, len, 1, DISPLAY_TEXT_SCROLL_STATIC, 500, 2000, FALSE, 0);
#endif
}
static QFontEngine *loadEngine(int script, const QFontDef &request,
HDC fontHdc, int dpi, bool rawMode,
const QtFontDesc *desc,
const QStringList &family_list)
{
LOGFONT lf;
memset(&lf, 0, sizeof(LOGFONT));
bool useDevice = (request.styleStrategy & QFont::PreferDevice) && fontHdc;
HDC hdc = shared_dc();
QString font_name = desc != 0 ? desc->family->name : request.family;
if (useDevice) {
hdc = fontHdc;
font_name = request.family;
}
bool stockFont = false;
bool preferClearTypeAA = false;
HFONT hfont = 0;
#if !defined(QT_NO_DIRECTWRITE)
bool useDirectWrite = (request.hintingPreference == QFont::PreferNoHinting)
|| (request.hintingPreference == QFont::PreferVerticalHinting);
IDWriteFont *directWriteFont = 0;
#else
bool useDirectWrite = false;
#endif
if (rawMode) { // will choose a stock font
int f, deffnt = SYSTEM_FONT;
QString fam = desc != 0 ? desc->family->name.toLower() : request.family.toLower();
if (fam == QLatin1String("default"))
f = deffnt;
else if (fam == QLatin1String("system"))
f = SYSTEM_FONT;
#ifndef Q_WS_WINCE
else if (fam == QLatin1String("system_fixed"))
f = SYSTEM_FIXED_FONT;
else if (fam == QLatin1String("ansi_fixed"))
f = ANSI_FIXED_FONT;
else if (fam == QLatin1String("ansi_var"))
f = ANSI_VAR_FONT;
else if (fam == QLatin1String("device_default"))
f = DEVICE_DEFAULT_FONT;
else if (fam == QLatin1String("oem_fixed"))
f = OEM_FIXED_FONT;
#endif
else if (fam[0] == QLatin1Char('#'))
f = fam.right(fam.length()-1).toInt();
else
f = deffnt;
hfont = (HFONT)GetStockObject(f);
if (!hfont) {
qErrnoWarning("QFontEngine::loadEngine: GetStockObject failed");
hfont = systemFont();
}
stockFont = true;
} else {
int hint = FF_DONTCARE;
switch (request.styleHint) {
case QFont::Helvetica:
hint = FF_SWISS;
break;
case QFont::Times:
hint = FF_ROMAN;
break;
case QFont::Courier:
hint = FF_MODERN;
break;
case QFont::OldEnglish:
hint = FF_DECORATIVE;
break;
case QFont::System:
hint = FF_MODERN;
break;
default:
break;
}
lf.lfHeight = -qRound(request.pixelSize);
lf.lfWidth = 0;
lf.lfEscapement = 0;
lf.lfOrientation = 0;
if (desc == 0 || desc->style->key.weight == 50)
lf.lfWeight = FW_DONTCARE;
else
lf.lfWeight = (desc->style->key.weight*900)/99;
lf.lfItalic = (desc != 0 && desc->style->key.style != QFont::StyleNormal);
lf.lfCharSet = DEFAULT_CHARSET;
int strat = OUT_DEFAULT_PRECIS;
if (request.styleStrategy & QFont::PreferBitmap) {
strat = OUT_RASTER_PRECIS;
#ifndef Q_WS_WINCE
} else if (request.styleStrategy & QFont::PreferDevice) {
strat = OUT_DEVICE_PRECIS;
} else if (request.styleStrategy & QFont::PreferOutline) {
strat = OUT_OUTLINE_PRECIS;
} else if (request.styleStrategy & QFont::ForceOutline) {
strat = OUT_TT_ONLY_PRECIS;
#endif
}
lf.lfOutPrecision = strat;
int qual = DEFAULT_QUALITY;
if (request.styleStrategy & QFont::PreferMatch)
qual = DRAFT_QUALITY;
#ifndef Q_WS_WINCE
else if (request.styleStrategy & QFont::PreferQuality)
qual = PROOF_QUALITY;
#endif
if (request.styleStrategy & QFont::PreferAntialias) {
if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP) {
qual = CLEARTYPE_QUALITY;
preferClearTypeAA = true;
} else {
qual = ANTIALIASED_QUALITY;
}
} else if (request.styleStrategy & QFont::NoAntialias) {
qual = NONANTIALIASED_QUALITY;
}
lf.lfQuality = qual;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfPitchAndFamily = DEFAULT_PITCH | hint;
QString fam = font_name;
if(fam.isEmpty())
fam = QLatin1String("MS Sans Serif");
if ((fam == QLatin1String("MS Sans Serif"))
&& (request.style == QFont::StyleItalic || (-lf.lfHeight > 18 && -lf.lfHeight != 24))) {
fam = QLatin1String("Arial"); // MS Sans Serif has bearing problems in italic, and does not scale
}
if (fam == QLatin1String("Courier") && !(request.styleStrategy & QFont::PreferBitmap))
fam = QLatin1String("Courier New");
memcpy(lf.lfFaceName, fam.utf16(), sizeof(wchar_t) * qMin(fam.length() + 1, 32)); // 32 = Windows hard-coded
hfont = CreateFontIndirect(&lf);
if (!hfont)
qErrnoWarning("QFontEngine::loadEngine: CreateFontIndirect failed");
stockFont = (hfont == 0);
bool ttf = false;
int avWidth = 0;
BOOL res;
HGDIOBJ oldObj = SelectObject(hdc, hfont);
TEXTMETRIC tm;
res = GetTextMetrics(hdc, &tm);
avWidth = tm.tmAveCharWidth;
ttf = tm.tmPitchAndFamily & TMPF_TRUETYPE;
SelectObject(hdc, oldObj);
if (!ttf || !useDirectWrite) {
useDirectWrite = false;
if (hfont && (!ttf || request.stretch != 100)) {
DeleteObject(hfont);
if (!res)
qErrnoWarning("QFontEngine::loadEngine: GetTextMetrics failed");
lf.lfWidth = avWidth * request.stretch/100;
hfont = CreateFontIndirect(&lf);
if (!hfont)
qErrnoWarning("QFontEngine::loadEngine: CreateFontIndirect with stretch failed");
}
#ifndef Q_WS_WINCE
if (hfont == 0) {
hfont = (HFONT)GetStockObject(ANSI_VAR_FONT);
stockFont = true;
}
#else
if (hfont == 0) {
hfont = (HFONT)GetStockObject(SYSTEM_FONT);
stockFont = true;
}
#endif
}
#if !defined(QT_NO_DIRECTWRITE)
else {
// Default to false for DirectWrite (and re-enable once/if everything
// turns out okay)
useDirectWrite = false;
QFontDatabasePrivate *db = privateDb();
if (db->directWriteFactory == 0) {
HRESULT hr = DWriteCreateFactory(
DWRITE_FACTORY_TYPE_SHARED,
__uuidof(IDWriteFactory),
reinterpret_cast<IUnknown **>(&db->directWriteFactory)
);
if (FAILED(hr)) {
qErrnoWarning("QFontEngine::loadEngine: DWriteCreateFactory failed");
} else {
hr = db->directWriteFactory->GetGdiInterop(&db->directWriteGdiInterop);
if (FAILED(hr))
qErrnoWarning("QFontEngine::loadEngine: GetGdiInterop failed");
}
}
if (db->directWriteGdiInterop != 0) {
QString nameSubstitute = fontNameSubstitute(QString::fromWCharArray(lf.lfFaceName));
memcpy(lf.lfFaceName, nameSubstitute.utf16(),
sizeof(wchar_t) * qMin(nameSubstitute.length() + 1, LF_FACESIZE));
HRESULT hr = db->directWriteGdiInterop->CreateFontFromLOGFONT(
&lf,
&directWriteFont);
if (FAILED(hr)) {
#ifndef QT_NO_DEBUG
qErrnoWarning("QFontEngine::loadEngine: CreateFontFromLOGFONT failed "
"for %ls (0x%lx)",
lf.lfFaceName, hr);
#endif
} else {
DeleteObject(hfont);
useDirectWrite = true;
}
}
}
#endif
}
QFontEngine *fe = 0;
if (!useDirectWrite) {
QFontEngineWin *few = new QFontEngineWin(font_name, hfont, stockFont, lf);
if (preferClearTypeAA)
few->glyphFormat = QFontEngineGlyphCache::Raster_RGBMask;
// Also check for OpenType tables when using complex scripts
// ### TODO: This only works for scripts that require OpenType. More generally
// for scripts that do not require OpenType we should just look at the list of
// supported writing systems in the font's OS/2 table.
if (scriptRequiresOpenType(script)) {
HB_Face hbFace = few->harfbuzzFace();
if (!hbFace || !hbFace->supported_scripts[script]) {
FM_DEBUG(" OpenType support missing for script\n");
delete few;
return 0;
}
}
initFontInfo(few, request, fontHdc, dpi);
fe = few;
}
#if !defined(QT_NO_DIRECTWRITE)
else {
QFontDatabasePrivate *db = privateDb();
IDWriteFontFace *directWriteFontFace = NULL;
HRESULT hr = directWriteFont->CreateFontFace(&directWriteFontFace);
if (SUCCEEDED(hr)) {
QFontEngineDirectWrite *fedw = new QFontEngineDirectWrite(db->directWriteFactory,
directWriteFontFace,
request.pixelSize);
initFontInfo(fedw, request, dpi, directWriteFont);
fe = fedw;
} else {
qErrnoWarning(hr, "QFontEngine::loadEngine: CreateFontFace failed");
}
}
if (directWriteFont != 0)
directWriteFont->Release();
#endif
if(script == QUnicodeTables::Common
&& !(request.styleStrategy & QFont::NoFontMerging)
&& desc != 0
&& !(desc->family->writingSystems[QFontDatabase::Symbol] & QtFontFamily::Supported)) {
if(!tryFonts) {
LANGID lid = GetUserDefaultLangID();
switch( lid&0xff ) {
case LANG_CHINESE: // Chinese (Taiwan)
if ( lid == 0x0804 ) // Taiwan
tryFonts = ch_TW_tryFonts;
else
tryFonts = ch_CN_tryFonts;
break;
case LANG_JAPANESE:
tryFonts = jp_tryFonts;
break;
case LANG_KOREAN:
tryFonts = kr_tryFonts;
break;
default:
tryFonts = other_tryFonts;
break;
}
}
QStringList fm = QFontDatabase().families();
QStringList list = family_list;
const char **tf = tryFonts;
while(tf && *tf) {
if(fm.contains(QLatin1String(*tf)))
list << QLatin1String(*tf);
++tf;
}
QFontEngine *mfe = new QFontEngineMultiWin(fe, list);
mfe->fontDef = fe->fontDef;
fe = mfe;
}
return fe;
}
/*!
\internal
*/
QFontEngine *
QFontDatabase::findFont(int script, const QFontPrivate *fp,
const QFontDef &request)
{
QMutexLocker locker(fontDatabaseMutex());
const int force_encoding_id = -1;
if (!privateDb()->count)
initializeDb();
QFontEngine *engine;
QFontCache::Key key(request, script);
engine = QFontCache::instance()->findEngine(key);
if (engine) {
qDebug() << "Cache hit level 1";
return engine;
}
QString family_name, foundry_name;
parseFontName(request.family, foundry_name, family_name);
if (qt_enable_test_font && request.family == QLatin1String("__Qt__Box__Engine__")) {
engine =new QTestFontEngine(request.pixelSize);
engine->fontDef = request;
}
QtFontDesc desc;
match(script, request, family_name, foundry_name, force_encoding_id, &desc);
if (desc.family != 0 && desc.foundry != 0 && desc.style != 0) {
engine = loadEngine(script, request, desc.family, desc.foundry, desc.style, desc.size);
} else {
FM_DEBUG(" NO MATCH FOUND\n");
}
if (engine) {
initFontDef(desc, request, &engine->fontDef);
if (fp) {
QFontDef def = request;
if (def.family.isEmpty()) {
def.family = fp->request.family;
def.family = def.family.left(def.family.indexOf(QLatin1Char(',')));
}
}
}
if (!engine) {
if (!request.family.isEmpty()) {
QStringList fallbacks = fallbackFamilies(request.family,QFont::Style(request.style),QFont::StyleHint(request.styleHint),QUnicodeTables::Script(script));
for (int i = 0; i < fallbacks.size(); i++) {
QFontDef def = request;
def.family = fallbacks.at(i);
QFontCache::Key key(def,script);
engine = QFontCache::instance()->findEngine(key);
if (!engine) {
QtFontDesc desc;
match(script, def, def.family, QLatin1String(""), 0, &desc);
if (desc.family == 0 && desc.foundry == 0 && desc.style == 0) {
continue;
}
engine = loadEngine(script, def, desc.family, desc.foundry, desc.style, desc.size);
if (engine) {
initFontDef(desc, def, &engine->fontDef);
break;
}
}
}
}
if (!engine)
engine = new QFontEngineBox(request.pixelSize);
FM_DEBUG("returning box engine");
}
if (fp && fp->dpi > 0) {
engine->fontDef.pointSize = qreal(double((engine->fontDef.pixelSize * 72) / fp->dpi));
} else {
engine->fontDef.pointSize = request.pointSize;
}
return engine;
}
/****************************************************************************
NAME
sinkFmRxAudioConnect
DESCRIPTION
connects the I2S FM audio via the FM audio plugin which allows tones play
and volume control
RETURNS
nothing
*/
void sinkFmRxAudioConnect(void)
{
AUDIO_PLUGIN_SET_VOLUME_A2DP_MSG_T volumeDsp;
uint16 volume_dB = VolumeConvertStepsToDB(theSink.volume_levels->fm_volume.masterVolume, &theSink.conf1->volume_config.volume_control_config, DSP_DB_SCALE);
uint16 mode = (theSink.volume_levels->fm_volume.masterVolume == VOLUME_A2DP_MUTE_GAIN) ? AUDIO_MODE_MUTE_SPEAKER : AUDIO_MODE_CONNECTED;
FM_DEBUG(("sinkFmRxAudioConnect \n"));
theSink.volume_levels->fm_volume.tonesVolume = VolumeConvertStepsToDB(((TonesGetToneVolume(FALSE) * theSink.conf1->volume_config.volume_control_config.no_of_steps)/VOLUME_NUM_VOICE_STEPS), &theSink.conf1->volume_config.volume_control_config, DSP_DB_SCALE);
/* Make sure we're using correct parameters for FM audio */
theSink.a2dp_link_data->a2dp_audio_connect_params.mode_params = &theSink.a2dp_link_data->a2dp_audio_mode_params;
#ifdef ENABLE_SUBWOOFER
/* set the sub woofer link type prior to passing to audio connect */
theSink.a2dp_link_data->a2dp_audio_connect_params.sub_woofer_type = AUDIO_SUB_WOOFER_NONE;
theSink.a2dp_link_data->a2dp_audio_connect_params.sub_sink = NULL;
/* bits inverted in dsp plugin */
sinkAudioSetEnhancement(MUSIC_CONFIG_SUB_WOOFER_BYPASS,TRUE);
#else
/* no subwoofer support, set the sub woofer bypass bit in music config message sent o dsp */
sinkAudioSetEnhancement(MUSIC_CONFIG_SUB_WOOFER_BYPASS,FALSE);
#endif
FM_DEBUG(("FM: Routing (Vol %d)\n", theSink.volume_levels->fm_volume.masterVolume));
AudioConnect((TaskData *)&csr_fm_decoder_plugin,
theSink.routed_audio,
AUDIO_SINK_FM,
theSink.codec_task,
volume_dB,
FM_RATE,
theSink.conf2->audio_routing_data.PluginFeatures,
mode,
AUDIO_ROUTE_INTERNAL,
powerManagerGetLBIPM(),
&theSink.a2dp_link_data->a2dp_audio_connect_params,
&theSink.task);
audioControlLowPowerCodecs (FALSE) ;
/* update volume via a2dp common plugin */
volumeDsp.volume_type = theSink.conf1->volume_config.volume_control_config.volume_type;
volumeDsp.codec_task = theSink.codec_task;
volumeDsp.master_gain = volume_dB;
volumeDsp.tones_gain = theSink.volume_levels->fm_volume.tonesVolume;
volumeDsp.system_gain = theSink.conf1->volume_config.volume_control_config.system_volume;
volumeDsp.trim_gain_left = theSink.conf1->volume_config.volume_control_config.trim_volume_left;
volumeDsp.trim_gain_right= theSink.conf1->volume_config.volume_control_config.trim_volume_right;
volumeDsp.device_trim_master = theSink.conf1->volume_config.volume_control_config.device_trim_master;
volumeDsp.device_trim_slave = theSink.conf1->volume_config.volume_control_config.device_trim_slave;
volumeDsp.mute_active = theSink.sink_mute_status;
AudioSetVolumeA2DP ( &volumeDsp);
#ifdef ENABLE_SUBWOOFER
/* set subwoofer volume level */
updateSwatVolume(volume_dB);
#endif
/* tune to stored frequency after initilising the I2S interface otherwise FM receiver
may be in an unknown state which may not work reliably */
fmRxTuneFrequency(theSink.conf2->sink_fm_data.fmRxTunedFreq);
}
/****************************************************************************
NAME
sinkFmTuneDown
DESCRIPTION
initiates an FM auto tune in a decreasing frequency direction
RETURNS
nothing
*/
void sinkFmRxTuneDown(void)
{
FM_DEBUG(("sinkFmRxTuneDown \n"));
fmRxTuneDown();
}
/****************************************************************************
NAME
sinkFmTuneUp
DESCRIPTION
initiates an FM auto tune in an increasing frequency direction
RETURNS
nothing
*/
void sinkFmRxTuneUp(void)
{
FM_DEBUG(("sinkFmRxTuneUp \n"));
fmRxTuneUp();
}
