void print_capabilities(audio_output_t *ao, mpg123_handle *mh)
{
int r,e;
const long *rates;
size_t num_rates;
const int *encs;
size_t num_encs;
const char *name = "<buffer>";
const char *dev = "<none>";
if(!param.usebuffer)
{
name = ao->module ? ao->module->name : "file/raw/test";
if(ao->device != NULL) dev = ao->device;
}
mpg123_rates(&rates, &num_rates);
mpg123_encodings(&encs, &num_encs);
fprintf(stderr,"\nAudio driver: %s\nAudio device: %s\nAudio capabilities:\n(matrix of [S]tereo or [M]ono support for sample format and rate in Hz)\n |", name, dev);
for(e=0;e<num_encs;e++) fprintf(stderr," %5s |",audio_encoding_name(encs[e], 0));
fprintf(stderr,"\n ------|");
for(e=0;e<num_encs;e++) fprintf(stderr,"-------|");
fprintf(stderr, "\n");
for(r=0; r<num_rates; ++r) capline(mh, rates[r]);
if(param.force_rate) capline(mh, param.force_rate);
fprintf(stderr,"\n");
}
JNIEXPORT jintArray JNICALL Java_com_axelby_podax_player_MPG123_getSupportedRates
(JNIEnv *env, jclass c)
{
const long *list;
size_t i, number;
mpg123_rates(&list, &number);
jintArray result = (*env)->NewIntArray(env, number);
jint *resultData = (jint *)(*env)->GetPrimitiveArrayCritical(env, result, 0);
for (i = 0; i < number; i++)
resultData[i] = list[i];
(*env)->ReleasePrimitiveArrayCritical(env, result, resultData, 0);
return result;
}
static void
gst_mpg123_audio_dec_class_init (GstMpg123AudioDecClass * klass)
{
GstAudioDecoderClass *base_class;
GstElementClass *element_class;
GstPadTemplate *src_template, *sink_template;
int error;
GST_DEBUG_CATEGORY_INIT (mpg123_debug, "mpg123", 0, "mpg123 mp3 decoder");
base_class = GST_AUDIO_DECODER_CLASS (klass);
element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_set_static_metadata (element_class,
"mpg123 mp3 decoder",
"Codec/Decoder/Audio",
"Decodes mp3 streams using the mpg123 library",
"Carlos Rafael Giani <*****@*****.**>");
/* Not using static pad template for srccaps, since the comma-separated list
* of formats needs to be created depending on whatever mpg123 supports */
{
const int *format_list;
const long *rates_list;
size_t num, i;
GString *s;
GstCaps *src_template_caps;
s = g_string_new ("audio/x-raw, ");
mpg123_encodings (&format_list, &num);
g_string_append (s, "format = { ");
for (i = 0; i < num; ++i) {
switch (format_list[i]) {
case MPG123_ENC_SIGNED_16:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (S16));
break;
case MPG123_ENC_UNSIGNED_16:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (U16));
break;
case MPG123_ENC_SIGNED_24:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (S24));
break;
case MPG123_ENC_UNSIGNED_24:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (U24));
break;
case MPG123_ENC_SIGNED_32:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (S32));
break;
case MPG123_ENC_UNSIGNED_32:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (U32));
break;
case MPG123_ENC_FLOAT_32:
g_string_append (s, (i > 0) ? ", " : "");
g_string_append (s, GST_AUDIO_NE (F32));
break;
default:
GST_DEBUG ("Ignoring mpg123 format %d", format_list[i]);
break;
}
}
g_string_append (s, " }, ");
mpg123_rates (&rates_list, &num);
g_string_append (s, "rate = (int) { ");
for (i = 0; i < num; ++i) {
g_string_append_printf (s, "%s%lu", (i > 0) ? ", " : "", rates_list[i]);
}
g_string_append (s, "}, ");
g_string_append (s, "channels = (int) [ 1, 2 ], ");
g_string_append (s, "layout = (string) interleaved");
src_template_caps = gst_caps_from_string (s->str);
src_template = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
src_template_caps);
g_string_free (s, TRUE);
}
sink_template = gst_static_pad_template_get (&static_sink_template);
gst_element_class_add_pad_template (element_class, sink_template);
gst_element_class_add_pad_template (element_class, src_template);
base_class->start = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_start);
base_class->stop = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_stop);
base_class->handle_frame =
GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_handle_frame);
base_class->set_format = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_set_format);
base_class->flush = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_flush);
error = mpg123_init ();
if (G_UNLIKELY (error != MPG123_OK))
GST_ERROR ("Could not initialize mpg123 library: %s",
mpg123_plain_strerror (error));
else
GST_INFO ("mpg123 library initialized");
}
/* This uses the currently opened audio device, queries its caps.
In case of buffered playback, this works _once_ by querying the buffer for the caps before entering the main loop. */
void audio_capabilities(audio_output_t *ao, mpg123_handle *mh)
{
int force_fmt = 0;
int fmts;
size_t ri;
/* Pitching introduces a difference between decoder rate and playback rate. */
long rate, decode_rate;
int channels;
const long *rates;
size_t num_rates, rlimit;
debug("audio_capabilities");
mpg123_rates(&rates, &num_rates);
mpg123_format_none(mh); /* Start with nothing. */
if(param.force_encoding != NULL)
{
int i;
if(!param.quiet) fprintf(stderr, "Note: forcing output encoding %s\n", param.force_encoding);
for(i=0;i<KNOWN_ENCS;++i)
if(!strncasecmp(encdesc[i].name, param.force_encoding, encdesc[i].nlen))
{
force_fmt = encdesc[i].code;
break;
}
if(i==KNOWN_ENCS)
{
error1("Failed to find an encoding to match requested \"%s\"!\n", param.force_encoding);
return; /* No capabilities at all... */
}
else if(param.verbose > 2) fprintf(stderr, "Note: forcing encoding code 0x%x\n", force_fmt);
}
rlimit = param.force_rate > 0 ? num_rates+1 : num_rates;
for(channels=1; channels<=2; channels++)
for(ri = 0;ri<rlimit;ri++)
{
decode_rate = ri < num_rates ? rates[ri] : param.force_rate;
rate = pitch_rate(decode_rate);
if(param.verbose > 2) fprintf(stderr, "Note: checking support for %liHz/%ich.\n", rate, channels);
#ifndef NOXFERMEM
if(param.usebuffer)
{ /* Ask the buffer process. It is waiting for this. */
buffermem->rate = rate;
buffermem->channels = channels;
buffermem->format = 0; /* Just have it initialized safely. */
debug2("asking for formats for %liHz/%ich", rate, channels);
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_AUDIOCAP);
xfermem_getcmd(buffermem->fd[XF_WRITER], TRUE);
fmts = buffermem->format;
}
else
#endif
{ /* Check myself. */
ao->rate = rate;
ao->channels = channels;
fmts = ao->get_formats(ao);
}
if(param.verbose > 2) fprintf(stderr, "Note: result 0x%x\n", fmts);
if(force_fmt)
{ /* Filter for forced encoding. */
if((fmts & force_fmt) == force_fmt) fmts = force_fmt;
else fmts = 0; /* Nothing else! */
if(param.verbose > 2) fprintf(stderr, "Note: after forcing 0x%x\n", fmts);
}
if(fmts < 0) continue;
else mpg123_format(mh, decode_rate, channels, fmts);
}
#ifndef NOXFERMEM
/* Buffer loop shall start normal operation now. */
if(param.usebuffer)
{
xfermem_putcmd(buffermem->fd[XF_WRITER], XF_CMD_WAKEUP);
xfermem_getcmd(buffermem->fd[XF_WRITER], TRUE);
}
#endif
if(param.verbose > 1) print_capabilities(ao, mh);
}
int _tmain(int argc, TCHAR **argv)
{
unsigned char buf[INBUFF];
unsigned char *audio;
FILE *in;
mpg123_handle *m;
int ret, state;
size_t inc, outc;
off_t len, num;
size_t bytes;
off_t inoffset;
size_t nrates;
const long *rates;
size_t i;
inc = outc = 0;
nrates = 0;
rates = NULL;
if(argc < 3)
{
fprintf(stderr,"Please supply in and out filenames\n");
return -1;
}
mpg123_init();
m = mpg123_new(NULL, &ret);
if(m == NULL)
{
fprintf(stderr,"Unable to create mpg123 handle: %s\n", mpg123_plain_strerror(ret));
return -1;
}
mpg123_param(m, MPG123_VERBOSE, 4, 0);
ret = mpg123_param(m, MPG123_FLAGS, MPG123_FUZZY | MPG123_SEEKBUFFER | MPG123_GAPLESS, 0);
if(ret != MPG123_OK)
{
fprintf(stderr,"Unable to set library options: %s\n", mpg123_plain_strerror(ret));
return -1;
}
// Let the seek index auto-grow and contain an entry for every frame
ret = mpg123_param(m, MPG123_INDEX_SIZE, -1, 0);
if(ret != MPG123_OK)
{
fprintf(stderr,"Unable to set index size: %s\n", mpg123_plain_strerror(ret));
return -1;
}
// Use float output formats only
ret = mpg123_format_none(m);
if(ret != MPG123_OK)
{
fprintf(stderr,"Unable to disable all output formats: %s\n", mpg123_plain_strerror(ret));
return -1;
}
mpg123_rates(&rates, &nrates);
for(i=0; i<nrates; i++)
{
ret = mpg123_format(m, rates[i], MPG123_MONO | MPG123_STEREO, MPG123_ENC_FLOAT_32);
if(ret != MPG123_OK)
{
fprintf(stderr,"Unable to set float output formats: %s\n", mpg123_plain_strerror(ret));
return -1;
}
}
ret = mpg123_open_feed(m);
if(ret != MPG123_OK)
{
fprintf(stderr,"Unable open feed: %s\n", mpg123_plain_strerror(ret));
return -1;
}
in = _tfopen(argv[1], __T("rb"));
if(in == NULL)
{
_ftprintf(stderr,__T("Unable to open input file %s\n"), argv[1]);
return -1;
}
out = _tfopen(argv[2], __T("wb"));
if(out == NULL)
{
_ftprintf(stderr,__T("Unable to open output file %s\n"), argv[2]);
return -1;
}
while(ret = mpg123_feedseek(m, 95000, SEEK_SET, &inoffset) == MPG123_NEED_MORE)
{
len = fread(buf, sizeof(unsigned char), INBUFF, in);
if(len <= 0)
break;
inc += len;
state = mpg123_feed(m, buf, len);
if(state == MPG123_ERR)
{
fprintf(stderr, "Error: %s", mpg123_strerror(m));
return -1;
}
}
fseek(in, inoffset, SEEK_SET);
while(1)
{
len = fread(buf, sizeof(unsigned char), INBUFF, in);
if(len <= 0)
break;
inc += len;
ret = mpg123_feed(m, buf, len);
while(ret != MPG123_ERR && ret != MPG123_NEED_MORE)
{
ret = mpg123_decode_frame(m, &num, &audio, &bytes);
if(ret == MPG123_NEW_FORMAT)
{
mpg123_getformat(m, &rate, &channels, &enc);
initwavformat();
initwav();
fprintf(stderr, "New format: %li Hz, %i channels, encoding value %i\n", rate, channels, enc);
}
fwrite(audio, sizeof(unsigned char), bytes, out);
outc += bytes;
}
if(ret == MPG123_ERR)
{
fprintf(stderr, "Error: %s", mpg123_strerror(m));
break;
}
}
fprintf(stderr, "Finished read %lu, decoded %lu\n", (unsigned long)inc, (unsigned long)outc);
closewav();
fclose(out);
fclose(in);
mpg123_delete(m);
mpg123_exit();
return 0;
}
static gboolean
xmms_mpg123_init (xmms_xform_t *xform)
{
xmms_mpg123_data_t *data;
const long *rates;
size_t num_rates;
int encoding;
off_t length;
int i, result;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_mpg123_data_t, 1);
xmms_xform_private_data_set (xform, data);
/* Get the total size of this stream and store it for later */
if (xmms_xform_metadata_get_int (xform,
XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE,
&result)) {
data->filesize = result;
}
mpg123_rates (&rates, &num_rates);
data->param = mpg123_new_pars (&result);
g_return_val_if_fail (data->param, FALSE);
/* Create a quiet (stderr) decoder with auto choosen optimization.
* Stuff set here should be tunable via plugin config properties!
* You can also change some things during playback...
*/
mpg123_par (data->param, MPG123_ADD_FLAGS, MPG123_QUIET, 0);
mpg123_par (data->param, MPG123_ADD_FLAGS, MPG123_GAPLESS, 0);
/* choose: MPG123_RVA_OFF, MPG123_RVA_MIX, MPG123_RVA_ALBUM
* xmms2 has its own ReplayGain plugin to handle the RVA field */
mpg123_par (data->param, MPG123_RVA, MPG123_RVA_OFF, 0);
/* You could choose a decoder from the list provided by
* mpg123_supported_decoders () and give that as second parameter.
*/
data->decoder = mpg123_parnew (data->param, NULL, &result);
if (data->decoder == NULL) {
xmms_log_error ("%s", mpg123_plain_strerror (result));
goto bad;
}
/* Prepare for buffer input feeding. */
result = mpg123_open_feed (data->decoder);
if (result != MPG123_OK) {
goto mpg123_bad;
}
/* Let's always decode to signed 16bit for a start.
Any mpg123-supported sample rate is accepted. */
if (MPG123_OK != mpg123_format_none (data->decoder)) {
goto mpg123_bad;
}
for (i = 0; i < num_rates; i++) {
result = mpg123_format (data->decoder, rates[i],
MPG123_MONO | MPG123_STEREO,
MPG123_ENC_SIGNED_16);
if (result != MPG123_OK) {
goto mpg123_bad;
}
}
/* Fetch ID3v1 data from the end of file if possible */
result = xmms_id3v1_get_tags (xform);
if (result < 0) {
xmms_log_error ("Seeking error when reading ID3v1 tags");
goto bad;
} else if (data->filesize > result) {
/* Reduce the size of tag data from the filesize */
data->filesize -= result;
}
/* Read data from input until decoded data is available from decoder */
do {
/* Parse stream and get info. */
gint ret;
xmms_error_t err;
ret = xmms_xform_read (xform, data->buf, BUFSIZE, &err);
if (ret < 0) {
xmms_log_error ("Error when trying to find beginning of stream");
goto bad;
} else if (ret == 0) {
/* EOF reached before format was found, handled after loop */
break;
}
/* With zero output size nothing is actually outputted */
result = mpg123_decode (data->decoder, data->buf,
(size_t) ret, NULL, 0, NULL);
} while (result == MPG123_NEED_MORE); /* Keep feeding... */
if (result != MPG123_NEW_FORMAT) {
xmms_log_error ("Unable to find beginning of stream (%s)!",
result == MPG123_ERR ? mpg123_strerror (data->decoder)
: "unexpected EOF");
goto bad;
}
result = mpg123_getformat (data->decoder, &data->samplerate,
&data->channels, &encoding);
if (result != MPG123_OK) {
goto mpg123_bad;
}
/* Set the filesize so it can be used for duration estimation */
if (data->filesize > 0) {
mpg123_set_filesize (data->decoder, data->filesize);
}
/* Get duration in samples, convert to ms and save to xmms2 */
length = mpg123_length (data->decoder);
if (length > 0 &&
!xmms_xform_metadata_get_int (xform,
XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION,
&i)) {
length = (off_t) ((gfloat) length / data->samplerate * 1000);
xmms_xform_metadata_set_int (xform,
XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION,
(gint) length);
}
XMMS_DBG ("mpg123: got stream with %li Hz %i channels, encoding %i",
data->samplerate, data->channels, encoding);
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm",
XMMS_STREAM_TYPE_FMT_FORMAT,
XMMS_SAMPLE_FORMAT_S16,
XMMS_STREAM_TYPE_FMT_CHANNELS,
data->channels,
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
(gint) data->samplerate,
XMMS_STREAM_TYPE_END);
return TRUE;
mpg123_bad:
xmms_log_error ("mpg123 error: %s", mpg123_strerror (data->decoder));
bad:
mpg123_delete (data->decoder);
mpg123_delete_pars (data->param);
g_free (data);
return FALSE;
}
