mirror of https://github.com/FWGS/xash3d-fwgs
436 lines
8.7 KiB
C
436 lines
8.7 KiB
C
/*
|
|
frame.c - compact version of famous library mpg123
|
|
Copyright (C) 2017 Uncle Mike
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "mpg123.h"
|
|
|
|
enum mpg123_channelcount
|
|
{
|
|
MPG123_MONO = 1,
|
|
MPG123_STEREO = 2
|
|
};
|
|
|
|
// only the standard rates
|
|
static const long my_rates[MPG123_RATES] =
|
|
{
|
|
8000, 11025, 12000,
|
|
16000, 22050, 24000,
|
|
32000, 44100, 48000,
|
|
};
|
|
|
|
static const int my_encodings[MPG123_ENCODINGS] =
|
|
{
|
|
MPG123_ENC_SIGNED_16,
|
|
MPG123_ENC_UNSIGNED_16,
|
|
};
|
|
|
|
// the list of actually possible encodings.
|
|
static const int good_encodings[] =
|
|
{
|
|
MPG123_ENC_SIGNED_16,
|
|
MPG123_ENC_UNSIGNED_16,
|
|
};
|
|
|
|
// check if encoding is a valid one in this build.
|
|
static int good_enc( const int enc )
|
|
{
|
|
size_t i;
|
|
|
|
for( i = 0; i < sizeof( good_encodings ) / sizeof( int ); ++i )
|
|
{
|
|
if( enc == good_encodings[i] )
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void mpg123_rates( const long **list, size_t *number )
|
|
{
|
|
if( number != NULL ) *number = sizeof( my_rates ) / sizeof( long );
|
|
if( list != NULL ) *list = my_rates;
|
|
}
|
|
|
|
// now that's a bit tricky... One build of the library knows only a subset of the encodings.
|
|
void mpg123_encodings( const int **list, size_t *number )
|
|
{
|
|
if( number != NULL ) *number = sizeof( good_encodings ) / sizeof( int );
|
|
if( list != NULL ) *list = good_encodings;
|
|
}
|
|
|
|
int mpg123_encsize( int encoding )
|
|
{
|
|
return sizeof( short );
|
|
}
|
|
|
|
static int rate2num( long r )
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < MPG123_RATES; i++ )
|
|
{
|
|
if( my_rates[i] == r )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int enc2num( int encoding )
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < MPG123_ENCODINGS; ++i )
|
|
{
|
|
if( my_encodings[i] == encoding )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int cap_fit( mpg123_handle_t *fr, audioformat_t *nf, int f0, int f2)
|
|
{
|
|
int i;
|
|
int c = nf->channels - 1;
|
|
int rn = rate2num( nf->rate );
|
|
|
|
if( rn >= 0 )
|
|
{
|
|
for( i = f0; i <f2; i++ )
|
|
{
|
|
if( fr->p.audio_caps[c][rn][i] )
|
|
{
|
|
nf->encoding = my_encodings[i];
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int freq_fit( mpg123_handle_t *fr, audioformat_t *nf, int f0, int f2 )
|
|
{
|
|
nf->rate = frame_freq( fr ) >> fr->p.down_sample;
|
|
|
|
if( cap_fit( fr, nf, f0, f2 ))
|
|
return 1;
|
|
|
|
if( fr->p.flags & MPG123_AUTO_RESAMPLE )
|
|
{
|
|
nf->rate >>= 1;
|
|
if( cap_fit( fr, nf, f0, f2 ))
|
|
return 1;
|
|
|
|
nf->rate >>= 1;
|
|
if( cap_fit( fr, nf, f0, f2 ))
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// match constraints against supported audio formats, store possible setup in frame
|
|
// return: -1: error; 0: no format change; 1: format change
|
|
int frame_output_format( mpg123_handle_t *fr )
|
|
{
|
|
int f0 = 0;
|
|
int f2 = MPG123_ENCODINGS;
|
|
mpg123_parm_t *p = &fr->p;
|
|
audioformat_t nf;
|
|
|
|
// initialize new format, encoding comes later
|
|
nf.channels = fr->stereo;
|
|
|
|
// force stereo is stronger
|
|
if( p->flags & MPG123_FORCE_MONO )
|
|
nf.channels = 1;
|
|
|
|
if( p->flags & MPG123_FORCE_STEREO )
|
|
nf.channels = 2;
|
|
|
|
if( freq_fit( fr, &nf, f0, 2 ))
|
|
goto end; // try rates with 16bit
|
|
|
|
if( freq_fit( fr, &nf, f0 <=2 ? 2 : f0, f2 ))
|
|
goto end; // ... 8bit
|
|
|
|
// try again with different stereoness
|
|
if( nf.channels == 2 && !( p->flags & MPG123_FORCE_STEREO ))
|
|
nf.channels = 1;
|
|
else if( nf.channels == 1 && !( p->flags & MPG123_FORCE_MONO ))
|
|
nf.channels = 2;
|
|
|
|
if( freq_fit( fr, &nf, f0, 2 ))
|
|
goto end; // try rates with 16bit
|
|
if( freq_fit( fr, &nf, f0 <= 2 ? 2 : f0, f2 ))
|
|
goto end; // ... 8bit
|
|
|
|
fr->err = MPG123_BAD_OUTFORMAT;
|
|
return -1;
|
|
end:
|
|
// here is the _good_ end.
|
|
// we had a successful match, now see if there's a change
|
|
if( nf.rate == fr->af.rate && nf.channels == fr->af.channels && nf.encoding == fr->af.encoding )
|
|
{
|
|
return 0; // the same format as before
|
|
}
|
|
else
|
|
{ // a new format
|
|
fr->af.rate = nf.rate;
|
|
fr->af.channels = nf.channels;
|
|
fr->af.encoding = nf.encoding;
|
|
|
|
// cache the size of one sample in bytes, for ease of use.
|
|
fr->af.encsize = mpg123_encsize( fr->af.encoding );
|
|
if( fr->af.encsize < 1 )
|
|
{
|
|
fr->err = MPG123_BAD_OUTFORMAT;
|
|
return -1;
|
|
}
|
|
|
|
// set up the decoder synth format. Might differ.
|
|
// without high-precision synths, 16 bit signed is the basis for
|
|
// everything higher than 8 bit.
|
|
if( fr->af.encsize > 2 )
|
|
{
|
|
fr->af.dec_enc = MPG123_ENC_SIGNED_16;
|
|
}
|
|
else
|
|
{
|
|
switch( fr->af.encoding )
|
|
{
|
|
case MPG123_ENC_UNSIGNED_16:
|
|
fr->af.dec_enc = MPG123_ENC_SIGNED_16;
|
|
break;
|
|
default:
|
|
fr->af.dec_enc = fr->af.encoding;
|
|
break;
|
|
}
|
|
}
|
|
|
|
fr->af.dec_encsize = mpg123_encsize( fr->af.dec_enc );
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static int mpg123_fmt_none( mpg123_parm_t *mp )
|
|
{
|
|
if( mp == NULL )
|
|
return MPG123_BAD_PARS;
|
|
|
|
memset( mp->audio_caps, 0, sizeof( mp->audio_caps ));
|
|
return MPG123_OK;
|
|
}
|
|
|
|
int mpg123_fmt_all( mpg123_parm_t *mp )
|
|
{
|
|
size_t rate, ch, enc;
|
|
|
|
if( mp == NULL )
|
|
return MPG123_BAD_PARS;
|
|
|
|
for( ch = 0; ch < NUM_CHANNELS; ++ch )
|
|
{
|
|
for( rate = 0; rate < MPG123_RATES+1; ++rate )
|
|
{
|
|
for( enc = 0; enc < MPG123_ENCODINGS; ++enc )
|
|
mp->audio_caps[ch][rate][enc] = good_enc( my_encodings[enc] );
|
|
}
|
|
}
|
|
|
|
return MPG123_OK;
|
|
}
|
|
|
|
static int mpg123_fmt( mpg123_parm_t *mp, long rate, int channels, int encodings )
|
|
{
|
|
int ie, ic, ratei;
|
|
int ch[2] = { 0, 1 };
|
|
|
|
if( mp == NULL )
|
|
return MPG123_BAD_PARS;
|
|
|
|
if(!( channels & ( MPG123_MONO|MPG123_STEREO )))
|
|
return MPG123_BAD_CHANNEL;
|
|
|
|
if(!( channels & MPG123_STEREO ))
|
|
ch[1] = 0;
|
|
else if(!( channels & MPG123_MONO ))
|
|
ch[0] = 1;
|
|
|
|
ratei = rate2num( rate );
|
|
if( ratei < 0 ) return MPG123_BAD_RATE;
|
|
|
|
// now match the encodings
|
|
for( ic = 0; ic < 2; ++ic )
|
|
{
|
|
for( ie = 0; ie < MPG123_ENCODINGS; ++ie )
|
|
{
|
|
if( good_enc( my_encodings[ie] ) && (( my_encodings[ie] & encodings ) == my_encodings[ie] ))
|
|
mp->audio_caps[ch[ic]][ratei][ie] = 1;
|
|
}
|
|
|
|
if( ch[0] == ch[1] )
|
|
break; // no need to do it again
|
|
}
|
|
|
|
return MPG123_OK;
|
|
}
|
|
|
|
static int mpg123_fmt_support( mpg123_parm_t *mp, long rate, int encoding )
|
|
{
|
|
int ratei, enci;
|
|
int ch = 0;
|
|
|
|
ratei = rate2num( rate );
|
|
enci = enc2num( encoding );
|
|
|
|
if( mp == NULL || ratei < 0 || enci < 0 )
|
|
return 0;
|
|
|
|
if( mp->audio_caps[0][ratei][enci] )
|
|
ch |= MPG123_MONO;
|
|
|
|
if( mp->audio_caps[1][ratei][enci] )
|
|
ch |= MPG123_STEREO;
|
|
|
|
return ch;
|
|
}
|
|
|
|
int mpg123_format_none( mpg123_handle_t *mh )
|
|
{
|
|
int r;
|
|
|
|
if( mh == NULL )
|
|
return MPG123_BAD_HANDLE;
|
|
|
|
r = mpg123_fmt_none( &mh->p );
|
|
|
|
if( r != MPG123_OK )
|
|
{
|
|
mh->err = r;
|
|
return MPG123_ERR;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
int mpg123_format_all( mpg123_handle_t *mh )
|
|
{
|
|
int r;
|
|
|
|
if( mh == NULL )
|
|
return MPG123_BAD_HANDLE;
|
|
|
|
r = mpg123_fmt_all( &mh->p );
|
|
|
|
if( r != MPG123_OK )
|
|
{
|
|
mh->err = r;
|
|
return MPG123_ERR;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
int mpg123_format( mpg123_handle_t *mh, long rate, int channels, int encodings )
|
|
{
|
|
int r;
|
|
|
|
if( mh == NULL )
|
|
return MPG123_BAD_HANDLE;
|
|
|
|
r = mpg123_fmt( &mh->p, rate, channels, encodings );
|
|
|
|
if( r != MPG123_OK )
|
|
{
|
|
mh->err = r;
|
|
return MPG123_ERR;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
int mpg123_format_support( mpg123_handle_t *mh, long rate, int encoding )
|
|
{
|
|
if( mh == NULL )
|
|
return 0;
|
|
|
|
return mpg123_fmt_support( &mh->p, rate, encoding );
|
|
}
|
|
|
|
// call this one to ensure that any valid format will be something different than this.
|
|
void invalidate_format( audioformat_t *af )
|
|
{
|
|
af->encoding = 0;
|
|
af->channels = 0;
|
|
af->rate = 0;
|
|
}
|
|
|
|
// number of bytes the decoder produces.
|
|
mpg_off_t decoder_synth_bytes( mpg123_handle_t *fr, mpg_off_t s )
|
|
{
|
|
return s * fr->af.dec_encsize * fr->af.channels;
|
|
}
|
|
|
|
// samples/bytes for output buffer after post-processing.
|
|
// take into account: channels, bytes per sample -- NOT resampling!
|
|
mpg_off_t samples_to_bytes( mpg123_handle_t *fr, mpg_off_t s )
|
|
{
|
|
return s * fr->af.encsize * fr->af.channels;
|
|
}
|
|
|
|
mpg_off_t bytes_to_samples( mpg123_handle_t *fr, mpg_off_t b )
|
|
{
|
|
return b / fr->af.encsize / fr->af.channels;
|
|
}
|
|
|
|
// number of bytes needed for decoding _and_ post-processing.
|
|
mpg_off_t outblock_bytes( mpg123_handle_t *fr, mpg_off_t s )
|
|
{
|
|
int encsize = (fr->af.encsize > fr->af.dec_encsize ? fr->af.encsize : fr->af.dec_encsize);
|
|
return s * encsize * fr->af.channels;
|
|
}
|
|
|
|
static void conv_s16_to_u16( outbuffer_t *buf )
|
|
{
|
|
int16_t *ssamples = (int16_t *)buf->data;
|
|
uint16_t *usamples = (uint16_t *)buf->data;
|
|
size_t count = buf->fill / sizeof( int16_t );
|
|
size_t i;
|
|
|
|
for( i = 0; i < count; ++i )
|
|
{
|
|
long tmp = (long)ssamples[i] + 32768;
|
|
usamples[i] = (uint16_t)tmp;
|
|
}
|
|
}
|
|
|
|
void postprocess_buffer( mpg123_handle_t *fr )
|
|
{
|
|
switch( fr->af.dec_enc )
|
|
{
|
|
case MPG123_ENC_SIGNED_16:
|
|
switch( fr->af.encoding )
|
|
{
|
|
case MPG123_ENC_UNSIGNED_16:
|
|
conv_s16_to_u16(&fr->buffer);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|