/**
* Return SPDIF sample rate index in audio_master_sampr_list. Since we base
* our reading on the actual SPDIF sample rate (which might be a bit
* inaccurate), we round off to the closest sample rate that is supported by
* SPDIF.
*/
int audio_get_spdif_sample_rate(void)
{
unsigned long measured_rate = spdif_measure_frequency();
/* Find which SPDIF sample rate we're closest to. */
return round_value_to_list32(measured_rate, audio_master_sampr_list,
SAMPR_NUM_FREQ, false);
} /* audio_get_spdif_sample_rate */
/* set frequency next frequency used by the audio hardware -
* what pcm_apply_settings will set */
void pcm_set_frequency(unsigned int samplerate)
{
logf("pcm_set_frequency");
int index;
#ifdef CONFIG_SAMPR_TYPES
unsigned int type = samplerate & SAMPR_TYPE_MASK;
samplerate &= ~SAMPR_TYPE_MASK;
/* For now, supported targets have direct conversion when configured with
* CONFIG_SAMPR_TYPES.
* Some hypothetical target with independent rates would need slightly
* different handling throughout this source. */
samplerate = pcm_sampr_to_hw_sampr(samplerate, type);
#endif /* CONFIG_SAMPR_TYPES */
index = round_value_to_list32(samplerate, hw_freq_sampr,
HW_NUM_FREQ, false);
if (samplerate != hw_freq_sampr[index])
index = HW_FREQ_DEFAULT; /* Invalid = default */
pcm_sampr = hw_freq_sampr[index];
pcm_fsel = index;
}
static void mp3_enc_convert_config(struct encoder_config *cfg,
bool global)
{
if (global)
{
global_settings.mp3_enc_config.bitrate =
round_value_to_list32(cfg->mp3_enc.bitrate, mp3_enc_bitr,
MP3_ENC_NUM_BITR, false);
}
else
{
if ((unsigned)global_settings.mp3_enc_config.bitrate > MP3_ENC_NUM_BITR)
global_settings.mp3_enc_config.bitrate = MP3_ENC_BITRATE_CFG_DEFAULT;
cfg->mp3_enc.bitrate = mp3_enc_bitr[global_settings.mp3_enc_config.bitrate];
}
} /* mp3_enc_convert_config */
/* mp3_enc: return encoder capabilities */
static void mp3_enc_get_caps(const struct encoder_config *cfg,
struct encoder_caps *caps,
bool for_config)
{
int i;
unsigned long bitr;
if (!for_config)
{
/* Overall encoder capabilities */
caps->samplerate_caps = MPEG1_SAMPR_CAPS | MPEG2_SAMPR_CAPS;
caps->channel_caps = CHN_CAP_ALL;
return;
}
/* Restrict caps based on config */
i = round_value_to_list32(cfg->mp3_enc.bitrate, mp3_enc_bitr,
MP3_ENC_NUM_BITR, false);
bitr = mp3_enc_bitr[i];
/* sample rate caps */
/* check if MPEG1 sample rates are available */
if ((bitr >= 32 && bitr <= 128) || bitr >= 160)
caps->samplerate_caps |= MPEG1_SAMPR_CAPS;
/* check if MPEG2 sample rates and mono are available */
if (bitr <= 160)
{
caps->samplerate_caps |= MPEG2_SAMPR_CAPS;
caps->channel_caps |= CHN_CAP_MONO;
}
/* check if stereo is available */
if (bitr >= 32)
caps->channel_caps |= CHN_CAP_STEREO;
} /* mp3_enc_get_caps */
/* mp3_enc: show the bitrate setting options */
static bool mp3_enc_bitrate(struct menucallback_data *data)
{
struct encoder_config *cfg = data->cfg;
static const struct opt_items items[] =
{
/* Available in MPEG Version: */
#ifdef HAVE_MPEG2_SAMPR
#if 0
/* this sounds awful no matter what */
{ "8 kBit/s", TALK_ID(8, UNIT_KBIT) }, /* 2 */
#endif
/* mono only */
{ "16 kBit/s", TALK_ID(16, UNIT_KBIT) }, /* 2 */
{ "24 kBit/s", TALK_ID(24, UNIT_KBIT) }, /* 2 */
#endif /* HAVE_MPEG2_SAMPR */
/* stereo/mono */
{ "32 kBit/s", TALK_ID(32, UNIT_KBIT) }, /* 1,2 */
{ "40 kBit/s", TALK_ID(40, UNIT_KBIT) }, /* 1,2 */
{ "48 kBit/s", TALK_ID(48, UNIT_KBIT) }, /* 1,2 */
{ "56 kBit/s", TALK_ID(56, UNIT_KBIT) }, /* 1,2 */
{ "64 kBit/s", TALK_ID(64, UNIT_KBIT) }, /* 1,2 */
{ "80 kBit/s", TALK_ID(80, UNIT_KBIT) }, /* 1,2 */
{ "96 kBit/s", TALK_ID(96, UNIT_KBIT) }, /* 1,2 */
{ "112 kBit/s", TALK_ID(112, UNIT_KBIT) }, /* 1,2 */
{ "128 kBit/s", TALK_ID(128, UNIT_KBIT) }, /* 1,2 */
/* Leave out 144 when there is both MPEG 1 and 2 */
#if defined(HAVE_MPEG2_SAMPR) && !defined (HAVE_MPEG1_SAMPR)
/* oddball MPEG2-only rate stuck in the middle */
{ "144 kBit/s", TALK_ID(144, UNIT_KBIT) }, /* 2 */
#endif
{ "160 kBit/s", TALK_ID(160, UNIT_KBIT) }, /* 1,2 */
#ifdef HAVE_MPEG1_SAMPR
/* stereo only */
{ "192 kBit/s", TALK_ID(192, UNIT_KBIT) }, /* 1 */
{ "224 kBit/s", TALK_ID(224, UNIT_KBIT) }, /* 1 */
{ "256 kBit/s", TALK_ID(256, UNIT_KBIT) }, /* 1 */
{ "320 kBit/s", TALK_ID(320, UNIT_KBIT) }, /* 1 */
#endif
};
unsigned long rate_list[ARRAYLEN(items)];
/* This is rather constant based upon the build but better than
storing and maintaining yet another list of numbers */
int n_rates = make_list_from_caps32(
MPEG1_BITR_CAPS | MPEG2_BITR_CAPS, mp3_enc_bitr,
0
#ifdef HAVE_MPEG1_SAMPR
| MPEG1_BITR_CAPS
#endif
#ifdef HAVE_MPEG2_SAMPR
#ifdef HAVE_MPEG1_SAMPR
| (MPEG2_BITR_CAPS & ~(MP3_BITR_CAP_144 | MP3_BITR_CAP_8))
#else
| (MPEG2_BITR_CAPS & ~(MP3_BITR_CAP_8))
#endif
#endif /* HAVE_MPEG2_SAMPR */
, rate_list);
int index = round_value_to_list32(cfg->mp3_enc.bitrate, rate_list,
n_rates, false);
bool res = set_option(str(LANG_BITRATE), &index, INT,
items, n_rates, NULL);
index = round_value_to_list32(rate_list[index], mp3_enc_bitr,
MP3_ENC_NUM_BITR, false);
cfg->mp3_enc.bitrate = mp3_enc_bitr[index];
return res;
} /* mp3_enc_bitrate */
