/****************************************************************************
* Applies a frequency-domain filter to audio data in the subband-domain. *
****************************************************************************/
static void ApplyFilter(struct mad_frame *Frame)
{
int Channel,
Sample,
Samples,
SubBand;
/* There is two application loops, each optimized for the number
* of audio channels to process. The first alternative is for
* two-channel frames, the second is for mono-audio.
*/
Samples=MAD_NSBSAMPLES(&Frame->header);
if(Frame->header.mode!=MAD_MODE_SINGLE_CHANNEL)
for(Channel=0;Channel<2;Channel++)
for(Sample=0;Sample<Samples;Sample++)
for(SubBand=0;SubBand<32;SubBand++)
Frame->sbsample[Channel][Sample][SubBand]=
mad_f_mul(Frame->sbsample[Channel][Sample][SubBand],
Filter[SubBand]);
else
for(Sample=0;Sample<Samples;Sample++)
for(SubBand=0;SubBand<32;SubBand++)
Frame->sbsample[0][Sample][SubBand]=
mad_f_mul(Frame->sbsample[0][Sample][SubBand],
Filter[SubBand]);
}
/*
* NAME: I_sample()
* DESCRIPTION: decode one requantized Layer I sample from a bitstream
*/
static
mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb)
{
mad_fixed_t sample;
sample = mad_bit_read(ptr, nb);
/* invert most significant bit, extend sign, then scale to fixed format */
sample ^= 1 << (nb - 1);
sample |= -(sample & (1 << (nb - 1)));
sample <<= MAD_F_FRACBITS - (nb - 1);
/* requantize the sample */
/* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */
sample += MAD_F_ONE >> (nb - 1);
return mad_f_mul(sample, linear_table[nb - 2]);
/* s' = factor * s'' */
/* (to be performed by caller) */
}
/*
* NAME: II_samples()
* DESCRIPTION: decode three requantized Layer II samples from a bitstream
*/
static
void II_samples(struct mad_bitptr *ptr,
struct quantclass const *quantclass,
mad_fixed_t output[3])
{
unsigned int nb, s, sample[3];
if ((nb = quantclass->group)) {
unsigned int c, nlevels;
/* degrouping */
c = mad_bit_read(ptr, quantclass->bits);
nlevels = quantclass->nlevels;
for (s = 0; s < 3; ++s) {
sample[s] = c % nlevels;
c /= nlevels;
}
}
else {
nb = quantclass->bits;
for (s = 0; s < 3; ++s)
sample[s] = mad_bit_read(ptr, nb);
}
for (s = 0; s < 3; ++s) {
mad_fixed_t requantized;
/* invert most significant bit, extend sign, then scale to fixed format */
requantized = sample[s] ^ (1 << (nb - 1));
requantized |= -(requantized & (1 << (nb - 1)));
requantized <<= MAD_F_FRACBITS - (nb - 1);
/* requantize the sample */
/* s'' = C * (s''' + D) */
output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C);
/* s' = factor * s'' */
/* (to be performed by caller) */
}
}
static
void II_samples(struct mad_bitptr *ptr,
struct quantclass const *quantclass,
mad_fixed_t output[3])
{
unsigned int nb, s, sample[3];
if ((nb = quantclass->group)) {
unsigned int c, nlevels;
c = mad_bit_read(ptr, quantclass->bits);
nlevels = quantclass->nlevels;
for (s = 0; s < 3; ++s) {
sample[s] = c % nlevels;
c /= nlevels;
}
}
else {
nb = quantclass->bits;
for (s = 0; s < 3; ++s)
sample[s] = mad_bit_read(ptr, nb);
}
for (s = 0; s < 3; ++s) {
mad_fixed_t requantized;
requantized = sample[s] ^ (1 << (nb - 1));
requantized |= -(requantized & (1 << (nb - 1)));
requantized <<= MAD_F_FRACBITS - (nb - 1);
/* s'' = C * (s''' + D) */
output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C);
/* s' = factor * s'' */
}
}
static
mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb)
{
mad_fixed_t sample;
sample = mad_bit_read(ptr, nb);
sample ^= 1 << (nb - 1);
sample |= -(sample & (1 << (nb - 1)));
sample <<= MAD_F_FRACBITS - (nb - 1);
/* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */
sample += MAD_F_ONE >> (nb - 1);
return mad_f_mul(sample, linear_table[nb - 2]);
/* s' = factor * s'' */
}
enum mad_flow output(void *data,
struct mad_header const *header,
struct mad_pcm *pcm)
{
register int nsamples = pcm->length;
mad_fixed_t const *left_ch = pcm->samples[0], *right_ch = pcm->samples[1];
static unsigned char stream[1152*4]; /* 1152 because that's what mad has as a max; *4 because
there are 4 distinct bytes per sample (in 2 channel case) */
static unsigned int rate = 0;
static int channels = 0;
static struct audio_dither dither;
register char * ptr = stream;
register signed int sample;
register mad_fixed_t tempsample;
/* Semaphore operations */
static struct sembuf read_sops = {0, -1, 0};
static struct sembuf write_sops = {1, 1, 0};
if(options.opt & MPG321_ENABLE_BUFFER)
{
semop(semarray,&read_sops,1);
ptr = (Output_Queue+mad_decoder_position)->data;
memcpy(&((Output_Queue+mad_decoder_position)->header),header,sizeof(struct mad_header));
}else{
/* We need to know information about the file before we can open the playdevice
in some cases. So, we do it here. */
if (!playdevice)
{
channels = MAD_NCHANNELS(header);
rate = header->samplerate;
open_ao_playdevice(header);
}
else if ((channels != MAD_NCHANNELS(header) || rate != header->samplerate) && playdevice_is_live())
{
ao_close(playdevice);
channels = MAD_NCHANNELS(header);
rate = header->samplerate;
open_ao_playdevice(header);
}
}
static int peak_rate = 0;
static unsigned short int peak = 0;
if (pcm->channels == 2)
{
while (nsamples--)
{
tempsample = mad_f_mul(*left_ch++, options.volume);
sample = (signed int) audio_linear_dither(16, tempsample, &dither);
peak = abs(sample) > peak ? abs(sample) : peak;
#ifndef WORDS_BIGENDIAN
*ptr++ = (unsigned char) (sample >> 0);
*ptr++ = (unsigned char) (sample >> 8);
#else
*ptr++ = (unsigned char) (sample >> 8);
*ptr++ = (unsigned char) (sample >> 0);
#endif
tempsample = mad_f_mul(*right_ch++, options.volume);
sample = (signed int) audio_linear_dither(16, tempsample, &dither);
peak = abs(sample) > peak ? abs(sample) : peak;
#ifndef WORDS_BIGENDIAN
*ptr++ = (unsigned char) (sample >> 0);
*ptr++ = (unsigned char) (sample >> 8);
#else
*ptr++ = (unsigned char) (sample >> 8);
*ptr++ = (unsigned char) (sample >> 0);
#endif
}
process_fft(stream, pcm->length * 4);
if(options.opt & MPG321_ENABLE_BUFFER)
{
(Output_Queue+mad_decoder_position)->length = pcm->length * 4;
}else
{
ao_play(playdevice, stream, pcm->length * 4);
}
}
else if (options.opt & MPG321_FORCE_STEREO)
process_fft(stream, pcm->length * 4);
if(options.opt & MPG321_ENABLE_BUFFER)
{
(Output_Queue+mad_decoder_position)->length = pcm->length * 4;
}else
{
ao_play(playdevice, stream, pcm->length * 4);
}
}
else if (options.opt & MPG321_FORCE_STEREO)
{
while (nsamples--)
{
tempsample = mad_f_mul(*left_ch++, options.volume);
sample = (signed int) audio_linear_dither(16, tempsample, &dither);
peak = abs(sample) > peak ? abs(sample) : peak;
/* Just duplicate the sample across both channels. */
#ifndef WORDS_BIGENDIAN
*ptr++ = (unsigned char) (sample >> 0);
*ptr++ = (unsigned char) (sample >> 8);
*ptr++ = (unsigned char) (sample >> 0);
*ptr++ = (unsigned char) (sample >> 8);
#else
*ptr++ = (unsigned char) (sample >> 8);
*ptr++ = (unsigned char) (sample >> 0);
*ptr++ = (unsigned char) (sample >> 8);
*ptr++ = (unsigned char) (sample >> 0);
/*
* NAME: resample_block()
* DESCRIPTION: algorithmically change the sampling rate of a PCM sample block
*/
unsigned int
mad_resample_block(struct resample_state *state,
unsigned int nsamples, mad_fixed_t const *old,
mad_fixed_t *newdata)
{
mad_fixed_t const *end, *begin;
/*
* This resampling algorithm is based on a linear interpolation, which is
* not at all the best sounding but is relatively fast and efficient.
*
* A better algorithm would be one that implements a bandlimited
* interpolation.
*/
if (state->ratio == MAD_F_ONE) {
memcpy(newdata, old, nsamples * sizeof(mad_fixed_t));
return nsamples;
}
end = old + nsamples;
begin = newdata;
if (state->step < 0)
{
state->step = mad_f_fracpart(-state->step);
while (state->step < MAD_F_ONE) {
*newdata++ = state->step ?
state->last + mad_f_mul(*old - state->last, state->step) : state->last;
state->step += state->ratio;
if (((state->step + 0x00000080L) & 0x0fffff00L) == 0)
state->step = (state->step + 0x00000080L) & ~0x0fffffffL;
}
state->step -= MAD_F_ONE;
}
while (end - old > 1 + mad_f_intpart(state->step))
{
old += mad_f_intpart(state->step);
state->step = mad_f_fracpart(state->step);
*newdata++ = state->step ?
*old + mad_f_mul(old[1] - old[0], state->step) : *old;
state->step += state->ratio;
if (((state->step + 0x00000080L) & 0x0fffff00L) == 0)
state->step = (state->step + 0x00000080L) & ~0x0fffffffL;
}
if (end - old == 1 + mad_f_intpart(state->step)) {
state->last = end[-1];
state->step = -state->step;
}
else
state->step -= mad_f_fromint(end - old);
return newdata - begin;
}
/*
* NAME: layer->II()
* DESCRIPTION: decode a single Layer II frame
*/
int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
struct mad_bitptr start;
unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb;
unsigned char const *offsets;
unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3];
mad_fixed_t samples[3];
nch = MAD_NCHANNELS(header);
if (header->flags & MAD_FLAG_LSF_EXT)
index = 4;
else {
switch (nch == 2 ? header->bitrate / 2 : header->bitrate) {
case 32000:
case 48000:
index = (header->samplerate == 32000) ? 3 : 2;
break;
case 56000:
case 64000:
case 80000:
index = 0;
break;
default:
index = (header->samplerate == 48000) ? 0 : 1;
}
}
sblimit = sbquant_table[index].sblimit;
offsets = sbquant_table[index].offsets;
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
if (bound > sblimit)
bound = sblimit;
start = stream->ptr;
/* decode bit allocations */
for (sb = 0; sb < bound; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
for (ch = 0; ch < nch; ++ch)
allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal);
}
for (sb = bound; sb < sblimit; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
allocation[0][sb] =
allocation[1][sb] = mad_bit_read(&stream->ptr, nbal);
}
/* decode scalefactor selection info */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb])
scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2);
}
}
/* check CRC word */
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(start, mad_bit_length(&start, &stream->ptr),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
/* decode scalefactors */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6);
switch (scfsi[ch][sb]) {
case 2:
scalefactor[ch][sb][2] =
scalefactor[ch][sb][1] =
scalefactor[ch][sb][0];
break;
case 0:
scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6);
/* fall through */
case 1:
case 3:
scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6);
}
if (scfsi[ch][sb] & 1)
scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1];
# if defined(OPT_STRICT)
/*
* Scalefactor index 63 does not appear in Table B.1 of
* ISO/IEC 11172-3. Nonetheless, other implementations accept it,
* so we only reject it if OPT_STRICT is defined.
*/
if (scalefactor[ch][sb][0] == 63 ||
scalefactor[ch][sb][1] == 63 ||
scalefactor[ch][sb][2] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
# endif
}
}
}
/* decode samples */
for (gr = 0; gr < 12; ++gr) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if ((index = allocation[ch][sb])) {
index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (s = 0; s < 3; ++s) {
frame->sbsample[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
else {
for (s = 0; s < 3; ++s)
frame->sbsample[ch][3 * gr + s][sb] = 0;
}
}
}
for (sb = bound; sb < sblimit; ++sb) {
if ((index = allocation[0][sb])) {
index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
frame->sbsample[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
}
else {
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s)
frame->sbsample[ch][3 * gr + s][sb] = 0;
}
}
}
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
for (sb = sblimit; sb < 32; ++sb)
frame->sbsample[ch][3 * gr + s][sb] = 0;
}
}
}
return 0;
}
/*
* NAME: layer->I()
* DESCRIPTION: decode a single Layer I frame
*/
int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
unsigned int nch, bound, ch, s, sb, nb;
unsigned char allocation[2][32], scalefactor[2][32];
nch = MAD_NCHANNELS(header);
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
/* check CRC word */
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
/* decode bit allocations */
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[ch][sb] = nb ? nb + 1 : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[0][sb] =
allocation[1][sb] = nb ? nb + 1 : 0;
}
/* decode scalefactors */
for (sb = 0; sb < 32; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb] = mad_bit_read(&stream->ptr, 6);
# if defined(OPT_STRICT)
/*
* Scalefactor index 63 does not appear in Table B.1 of
* ISO/IEC 11172-3. Nonetheless, other implementations accept it,
* so we only reject it if OPT_STRICT is defined.
*/
if (scalefactor[ch][sb] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
# endif
}
}
}
/* decode samples */
for (s = 0; s < 12; ++s) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = allocation[ch][sb];
frame->sbsample[ch][s][sb] = nb ?
mad_f_mul(I_sample(&stream->ptr, nb),
sf_table[scalefactor[ch][sb]]) : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
if ((nb = allocation[0][sb])) {
mad_fixed_t sample;
sample = I_sample(&stream->ptr, nb);
for (ch = 0; ch < nch; ++ch) {
frame->sbsample[ch][s][sb] =
mad_f_mul(sample, sf_table[scalefactor[ch][sb]]);
}
}
else {
for (ch = 0; ch < nch; ++ch)
frame->sbsample[ch][s][sb] = 0;
}
}
}
return 0;
}
int main(int argc, char* argv[])
{
FILE *fp1;
FILE *fp2;
FILE *fp3;
mad_fixed_t X[num_inp], T[num_out], H[num_hid], Y[num_out];
mad_fixed_t W_xh[num_inp][num_hid], W_hy[num_hid][num_out];
mad_fixed_t dW_xh[num_inp][num_hid], dW_hy[num_hid][num_out];
mad_fixed_t Q_h[num_hid], Q_y[num_out];
mad_fixed_t dQ_h[num_hid], dQ_y[num_out];
mad_fixed_t delta_h[num_hid], delta_y[num_out];
mad_fixed_t sum, mse;
int Icycle, Itrain;
int i, j, h;
fp1 = fopen(train_file, "r");
fp2 = fopen(weight_file, "w");
fp3 = fopen(mse_file, "w");
if (fp1 == NULL) {
puts("File not exist !!");
getchar();
exit(1);
}
srand((int)time(0));
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
W_xh[i][h] = random_value();
dW_xh[i][h] = F_ZERO;
}
}
for (j = 0; j <= num_out; j++) {
for (h = 0; h < num_hid; h++) {
W_hy[h][j] = random_value();
dW_hy[h][j] = F_ZERO;
}
}
for (h = 0; h < num_hid; h++) {
Q_h[h] = F_ZERO;
dQ_h[h] = F_ZERO;
delta_h[h] = F_ZERO;
}
for (j = 0; j < num_out; j++) {
Q_y[j] = random_value();
dQ_y[j] = F_ZERO;
delta_y[j] = F_ZERO;
}
/*start learning */
float tmp;
for (Icycle = 0; Icycle < num_cycle; Icycle++) {
mse = F_ZERO;
fseek(fp1, 0, 0);
for (Itrain = 0; Itrain < num_train; Itrain++) {
for (i = 0; i < num_inp; i++) {
tmp = parser(fp1);
X[i] = mad_f_tofixed(tmp);
}
for (j = 0; j < num_out; j++) {
tmp = parser(fp1);
T[j]= mad_f_tofixed(tmp);
}
for (h = 0; h < num_hid; h++) {
sum = F_ZERO;
for (i = 0; i < num_inp; i++) {
sum = mad_f_add(sum, mad_f_mul(X[i], W_xh[i][h]));
}
/* H[h] = (float)1.0 / (1.0 + exp(-(sum - Q_h[h]))); */
tmp = exp(-1.0 * mad_f_todouble(mad_f_sub(sum, Q_h[h])));
mad_fixed_t exp_result = mad_f_tofixed(tmp);
H[h] = mad_f_div(F_POS_ONE, mad_f_add(F_POS_ONE, exp_result));
}
for (j = 0; j < num_out; j++) {
sum = F_ZERO;
for (h = 0; h < num_hid; h++) {
sum = mad_f_add(sum, mad_f_mul(H[h], W_hy[h][j]));
}
/* Y[j] = (float)1.0 / (1.0 + exp(-(sum - Q_y[j]))); */
tmp = exp(-1.0 * mad_f_todouble(mad_f_sub(sum, Q_y[j])));
mad_fixed_t exp_result = mad_f_tofixed(tmp);
Y[j] = mad_f_div(F_POS_ONE, mad_f_add(F_POS_ONE, exp_result));
}
for (j = 0; j < num_out; j++) {
/* delta_y[j] = Y[j] * (1.0 - Y[j]) * (T[j] - Y[j]); */
mad_fixed_t first, second, third;
first = Y[j];
second = mad_f_sub(F_POS_ONE, Y[j]);
third = mad_f_sub(T[j], Y[j]);
delta_y[j] = mad_f_mul(mad_f_mul(first, second), third);
}
for (h = 0; h < num_hid; h++) {
sum = F_ZERO;
for (j = 0; j < num_out; j++) {
/* sum = sum + W_hy[h][j] * delta_y[j]; */
sum = mad_f_add(sum, mad_f_mul(W_hy[h][j], delta_y[j]));
}
/* delta_h[h] = H[h] * (1.0 - H[h]) * sum; */
mad_fixed_t first, second, third;
first = H[h];
second = mad_f_sub(F_POS_ONE, H[h]);
third = sum;
delta_h[h] = mad_f_mul(mad_f_mul(first, second), sum);
}
for (j = 0; j < num_out; j++) {
for (h = 0; h < num_hid; h++) {
/* dW_hy[h][j] = eta * delta_y[j] * H[h] + alpha * dW_hy[h][j]; */
mad_fixed_t first, second;
first = mad_f_mul(mad_f_mul(F_ETA, delta_y[j]), H[h]);
second = mad_f_mul(F_ALPHA, dW_hy[h][j]);
dW_hy[h][j] = mad_f_add(first, second);
}
}
for (j = 0; j < num_out; j++) {
/* dQ_y[j] = -eta * delta_y[j] + alpha * dQ_y[j]; */
mad_fixed_t first, second;
first = mad_f_mul(F_NEG_ETA, delta_y[j]);
second = mad_f_mul(F_ALPHA, dQ_y[j]);
dQ_y[j] = mad_f_add(first, second);
}
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
/* dW_xh[i][h] = eta * delta_h[h] * X[i] + alpha * dW_xh[i][h]; */
mad_fixed_t first, second;
first = mad_f_mul(X[i], mad_f_mul(F_ETA, delta_h[h]));
second = mad_f_mul(F_ALPHA, dW_xh[i][h]);
dW_xh[i][h] = mad_f_add(first, second);
}
}
for (h = 0; h < num_hid; h++) {
/* dQ_h[h] = -eta * delta_h[h] + alpha * dQ_h[h]; */
mad_fixed_t first, second;
first = mad_f_mul(F_NEG_ETA, delta_h[h]);
second = mad_f_mul(F_ALPHA, dQ_h[h]);
dQ_h[h] = mad_f_add(first, second);
}
for (j = 0; j < num_out; j++) {
for (h = 0; h < num_hid; h++) {
/* W_hy[h][j] = W_hy[h][j] + dW_hy[h][j]; */
tmp = mad_f_todouble(W_hy[h][j]);
W_hy[h][j] = mad_f_add(W_hy[h][j], dW_hy[h][j]);
}
}
for (j = 0; j < num_out; j++) {
/* Q_y[j] = Q_y[j] + dQ_y[j]; */
Q_y[j] = mad_f_add(Q_y[j], dQ_y[j]);
}
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
/* W_xh[i][h] = W_xh[i][h] + dW_xh[i][h]; */
W_xh[i][h] = mad_f_add(W_xh[i][h], dW_xh[i][h]);
}
}
for (h = 0; h < num_hid; h++) {
/* Q_h[h] = Q_h[h] + dQ_h[h]; */
Q_h[h] = mad_f_add(Q_h[h], dQ_h[h]);
}
for (j = 0; j < num_out; j++) {
/* mse += (T[j] - Y[j]) * (T[j] - Y[j]); */
mad_fixed_t first, second;
first = mad_f_sub(T[j], Y[j]);
second = mad_f_sub(T[j], Y[j]);
mse = mad_f_add(mse, mad_f_mul(first, second));
}
}
/* mse = mse / num_train; */
mse = mad_f_div(mse, mad_f_tofixed(num_train));
if ((Icycle % 10) == 9) {
printf("\nIcycle=%3d \nmse=%-8.6f\n", Icycle, mad_f_todouble(mse));
fprintf(fp3,"%3d \n%-8.6f\n", Icycle, mad_f_todouble(mse));
}
}
printf("\n");
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
printf("W_xh[%2d][%2d]=%-8.4f\t", i, h, mad_f_todouble(W_xh[i][h]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(W_xh[i][h]));
}
printf("\n");
fprintf(fp2,"\n");
}
printf("\n");
fprintf(fp2,"\n");
for (j = 0; j < num_out; j++) {
for (h = 0; h < num_hid; h++) {
printf("W_hy[%2d][%2d]=%-8.4f\t", h, j, mad_f_todouble(W_hy[h][j]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(W_hy[h][j]));
}
printf("\n");
fprintf(fp2,"\n");
}
printf("\n");
fprintf(fp2,"\n");
for (h = 0; h < num_hid; h++) {
printf("Q_h[%2d]=%-8.4f\t", h, mad_f_todouble(Q_h[h]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(Q_h[h]));
}
printf("\n\n");
fprintf(fp2,"\n\n");
for (j = 0; j < num_out; j++) {
printf("Q_y[%2d]=%-8.4f\t", j, mad_f_todouble(Q_y[j]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(Q_y[j]));
}
printf("\n\n");
fprintf(fp2,"\n\n");
fclose(fp1);
fclose(fp2);
fclose(fp3);
return 0;
}
/*
* NAME: layer->II()
* DESCRIPTION: decode a single Layer II frame
*/
int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
struct mad_bitptr start;
unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb;
unsigned char const *offsets;
unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3];
mad_fixed_t samples[3];
nch = MAD_NCHANNELS(header);
if (header->flags & MAD_FLAG_LSF_EXT)
index = 4;
else if (header->flags & MAD_FLAG_FREEFORMAT)
goto freeformat;
else {
unsigned long bitrate_per_channel;
bitrate_per_channel = header->bitrate;
if (nch == 2) {
bitrate_per_channel /= 2;
# if defined(OPT_STRICT)
/*
* ISO/IEC 11172-3 allows only single channel mode for 32, 48, 56, and
* 80 kbps bitrates in Layer II, but some encoders ignore this
* restriction. We enforce it if OPT_STRICT is defined.
*/
if (bitrate_per_channel <= 28000 || bitrate_per_channel == 40000) {
stream->error = MAD_ERROR_BADMODE;
return -1;
}
# endif
}
else { /* nch == 1 */
if (bitrate_per_channel > 192000) {
/*
* ISO/IEC 11172-3 does not allow single channel mode for 224, 256,
* 320, or 384 kbps bitrates in Layer II.
*/
stream->error = MAD_ERROR_BADMODE;
return -1;
}
}
if (bitrate_per_channel <= 48000)
index = (header->samplerate == 32000) ? 3 : 2;
else if (bitrate_per_channel <= 80000)
index = 0;
else {
freeformat:
index = (header->samplerate == 48000) ? 0 : 1;
}
}
sblimit = sbquant_table[index].sblimit;
offsets = sbquant_table[index].offsets;
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
if (bound > sblimit)
bound = sblimit;
start = stream->ptr;
/* decode bit allocations */
for (sb = 0; sb < bound; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
for (ch = 0; ch < nch; ++ch)
allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal);
}
for (sb = bound; sb < sblimit; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
allocation[0][sb] =
allocation[1][sb] = mad_bit_read(&stream->ptr, nbal);
}
/* decode scalefactor selection info */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb])
scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2);
}
}
/* check CRC word */
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(start, mad_bit_length(&start, &stream->ptr),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
/* decode scalefactors */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6);
switch (scfsi[ch][sb]) {
case 2:
scalefactor[ch][sb][2] =
scalefactor[ch][sb][1] =
scalefactor[ch][sb][0];
break;
case 0:
scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6);
/* fall through */
case 1:
case 3:
scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6);
}
if (scfsi[ch][sb] & 1)
scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1];
# if defined(OPT_STRICT)
/*
* Scalefactor index 63 does not appear in Table B.1 of
* ISO/IEC 11172-3. Nonetheless, other implementations accept it,
* so we only reject it if OPT_STRICT is defined.
*/
if (scalefactor[ch][sb][0] == 63 ||
scalefactor[ch][sb][1] == 63 ||
scalefactor[ch][sb][2] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
# endif
}
}
}
/* decode samples */
for (gr = 0; gr < 12; ++gr) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if ((index = allocation[ch][sb])) {
int off = bitalloc_table[offsets[sb]].offset;
index = offset_table[off][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (s = 0; s < 3; ++s) {
(*frame->sbsample)[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
else {
for (s = 0; s < 3; ++s)
(*frame->sbsample)[ch][3 * gr + s][sb] = 0;
}
}
}
for (sb = bound; sb < sblimit; ++sb) {
if ((index = allocation[0][sb])) {
int off = bitalloc_table[offsets[sb]].offset;
index = offset_table[off][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
(*frame->sbsample)[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
}
else {
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s)
(*frame->sbsample)[ch][3 * gr + s][sb] = 0;
}
}
}
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
for (sb = sblimit; sb < 32; ++sb)
(*frame->sbsample)[ch][3 * gr + s][sb] = 0;
}
}
}
return 0;
}
int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
unsigned int nch, bound, ch, s, sb, nb;
unsigned char allocation[2][32], scalefactor[2][32];
nch = MAD_NCHANNELS(header);
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[ch][sb] = nb ? nb + 1 : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[0][sb] =
allocation[1][sb] = nb ? nb + 1 : 0;
}
for (sb = 0; sb < 32; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb] = (unsigned char)(mad_bit_read(&stream->ptr, 6));
if (scalefactor[ch][sb] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
}
}
}
for (s = 0; s < 12; ++s) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = allocation[ch][sb];
frame->sbsample[ch][s][sb] = nb ?
mad_f_mul(I_sample(&stream->ptr, nb),
sf_table[scalefactor[ch][sb]]) : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
if ((nb = allocation[0][sb])) {
mad_fixed_t sample;
sample = I_sample(&stream->ptr, nb);
for (ch = 0; ch < nch; ++ch) {
frame->sbsample[ch][s][sb] =
mad_f_mul(sample, sf_table[scalefactor[ch][sb]]);
}
}
else {
for (ch = 0; ch < nch; ++ch)
frame->sbsample[ch][s][sb] = 0;
}
}
}
return 0;
}
/*
* NAME: fadein_filter()
* DESCRIPTION: fade-in filter
*/
enum mad_flow fadein_filter(void *data, struct mad_frame *frame)
{
struct player *player = data;
if (mad_timer_compare(player->stats.play_timer, player->fade_in) < 0) {
mad_timer_t frame_start, frame_end, ratio;
unsigned int nch, nsamples, s;
mad_fixed_t step, scalefactor;
/*
* Fade-in processing may occur over the entire frame, or it may end
* somewhere within the frame. Find out where processing should end.
*/
nsamples = MAD_NSBSAMPLES(&frame->header);
/* this frame has not yet been added to play_timer */
frame_start = frame_end = player->stats.play_timer;
mad_timer_add(&frame_end, frame->header.duration);
if (mad_timer_compare(player->fade_in, frame_end) < 0) {
mad_timer_t length;
length = frame_start;
mad_timer_negate(&length);
mad_timer_add(&length, player->fade_in);
mad_timer_set(&ratio, 0,
mad_timer_count(length, frame->header.samplerate),
mad_timer_count(frame->header.duration,
frame->header.samplerate));
nsamples = mad_timer_fraction(ratio, nsamples);
}
/* determine starting scalefactor and step size */
mad_timer_set(&ratio, 0,
mad_timer_count(frame_start, frame->header.samplerate),
mad_timer_count(player->fade_in, frame->header.samplerate));
scalefactor = mad_timer_fraction(ratio, MAD_F_ONE);
step = MAD_F_ONE / (mad_timer_count(player->fade_in,
frame->header.samplerate) / 32);
/* scale subband samples */
nch = MAD_NCHANNELS(&frame->header);
for (s = 0; s < nsamples; ++s) {
unsigned int ch, sb;
for (ch = 0; ch < nch; ++ch) {
for (sb = 0; sb < 32; ++sb) {
frame->sbsample[ch][s][sb] =
mad_f_mul(frame->sbsample[ch][s][sb], scalefactor);
}
}
scalefactor += step;
}
}
return MAD_FLOW_CONTINUE;
}
