Loading...
Searching...
No Matches
EST_Wave.cc
/*************************************************************************/
/* */
/* Centre for Speech Technology Research */
/* University of Edinburgh, UK */
/* Copyright (c) 1996 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/*************************************************************************/
/* Author : Paul Taylor and Alan Black */
/* Date : May 1996 */
/*-----------------------------------------------------------------------*/
/* EST_Wave Class source file */
/* */
/*=======================================================================*/
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <cstring>
#include "EST_cutils.h"
#include "EST_Wave.h"
#include "EST_wave_utils.h"
#include "EST_wave_aux.h"
#include "EST_TNamedEnum.h"
#include "EST_WaveFile.h"
#include "EST_Track.h"
#include "waveP.h"
#define sgn(x) (x>0?1:x?-1:0)
const EST_String DEF_FILE_TYPE = "riff";
const EST_String DEF_SAMPLE_TYPE = "short";
const int EST_Wave::default_sample_rate=16000;
EST_Wave::EST_Wave()
{
default_vals();
}
EST_Wave::EST_Wave(const EST_Wave &w)
{
default_vals();
copy(w);
}
EST_Wave::EST_Wave(int n, int c, int sr)
{
default_vals(n,c);
set_sample_rate(sr);
}
EST_Wave::EST_Wave(int samps, int chans,
short *memory, int offset, int sample_rate,
int free_when_destroyed)
{
default_vals();
p_values.set_memory(memory, offset, samps, chans, free_when_destroyed);
set_sample_rate(sample_rate);
}
void EST_Wave::default_vals(int n, int c)
{
// real defaults
p_values.resize(n,c);
p_sample_rate = default_sample_rate;
init_features();
}
void EST_Wave::free_wave()
{
if (!p_values.p_sub_matrix)
p_values.resize(0,0);
clear_features();
}
EST_Wave::~EST_Wave()
{
free_wave();
}
void EST_Wave::copy_setup(const EST_Wave &w)
{
p_sample_rate = w.p_sample_rate;
copy_features(w);
}
void EST_Wave::copy_data(const EST_Wave &w)
{
p_values.copy(w.p_values);
}
void EST_Wave::copy(const EST_Wave &w)
{
copy_setup(w);
copy_data(w);
}
short &EST_Wave::a(int i, int channel)
{
if (i<0 || i>= num_samples())
{
cerr << "Attempt to access sample " << i << " of a " << num_samples() << " sample wave.\n";
if (num_samples()>0)
return *(p_values.error_return);
}
if (channel<0 || channel>= num_channels())
{
cerr << "Attempt to access channel " << channel << " of a " << num_channels() << " channel wave.\n";
if (num_samples()>0)
return *(p_values.error_return);
}
return p_values.a_no_check(i,channel);
}
short EST_Wave::a(int i, int channel) const
{
return ((EST_Wave *)this)->a(i,channel);
}
short &EST_Wave::a_safe(int i, int channel)
{
static short out_of_bound_value = 0;
if ((i < 0) || (i >= num_samples()))
{ // need to give them something but they might have changed it
// so reinitialise it to 0 first
out_of_bound_value = 0;
return out_of_bound_value;
}
else
return a_no_check(i,channel);
}
void EST_Wave::fill(short v, int channel)
{
if (channel == EST_ALL)
{
if (v == 0) // this is *much* more efficient and common
memset(values().memory(),0,num_samples()*num_channels()*2);
else
p_values.fill(v);
}
else
for (int i = 0; i < num_samples(); ++i)
p_values.a_no_check(i,channel) = v;
}
EST_read_status EST_Wave::load(const EST_String filename,
int offset, int length,
int rate)
{
EST_read_status stat = read_error;
EST_TokenStream ts;
if ((ts.open(filename)) == -1)
{
cerr << "Wave load: can't open file \"" << filename << "\"" << endl;
return stat;
}
stat = load(ts,offset,length,rate);
ts.close();
return stat;
}
EST_read_status EST_Wave::load(EST_TokenStream &ts,
int offset, int length,
int rate)
{
EST_read_status stat = read_error;
int pos = ts.tell();
for(int n=0; n< EST_WaveFile::map.n() ; n++)
{
EST_WaveFileType t = EST_WaveFile::map.token(n);
if (t == wff_none)
continue;
EST_WaveFile::Info *info = &(EST_WaveFile::map.info(t));
if (! info->recognise)
continue;
EST_WaveFile::Load_TokenStream * l_fun =info->load;
if (l_fun == NULL)
continue;
ts.seek(pos);
stat = (*l_fun)(ts, *this,
rate, st_short, EST_NATIVE_BO, 1,
offset, length);
if (stat == read_ok)
{
set_file_type(EST_WaveFile::map.value(t));
break;
}
else if (stat == read_error)
break;
}
return stat;
}
EST_read_status EST_Wave::load(const EST_String filename,
const EST_String type,
int offset, int length,
int rate)
{
EST_read_status stat = read_error;
EST_TokenStream ts;
if (filename == "-")
ts.open(stdin,FALSE);
else if ((ts.open(filename)) == -1)
{
cerr << "Wave load: can't open file \"" << filename << "\"" << endl;
return stat;
}
stat = load(ts,type,offset,length,rate);
ts.close();
return stat;
}
EST_read_status EST_Wave::load(EST_TokenStream &ts,
const EST_String type,
int offset, int length,
int rate)
{
EST_WaveFileType t = EST_WaveFile::map.token(type);
if (t == wff_none)
{
cerr << "Unknown Wave file type " << type << endl;
return read_error;
}
EST_WaveFile::Load_TokenStream * l_fun = EST_WaveFile::map.info(t).load;
if (l_fun == NULL)
{
cerr << "Can't load waves to files type " << type << endl;
return read_error;
}
set_file_type(EST_WaveFile::map.value(t));
return (*l_fun)(ts, *this,
rate, st_short, EST_NATIVE_BO, 1,
offset, length);
}
EST_read_status EST_Wave::load_file(const EST_String filename,
const EST_String type, int sample_rate,
const EST_String stype, int bov, int nc, int offset,
int length)
{
EST_read_status stat = read_error;
EST_TokenStream ts;
if (filename == "-")
ts.open(stdin,FALSE);
else if ((ts.open(filename)) == -1)
{
cerr << "Wave load: can't open file \"" << filename << "\"" << endl;
return stat;
}
stat = load_file(ts,type,sample_rate,stype,bov,nc,offset,length);
ts.close();
return stat;
}
EST_read_status EST_Wave::load_file(EST_TokenStream &ts,
const EST_String type, int sample_rate,
const EST_String stype, int bov, int nc, int offset,
int length)
{
EST_WaveFileType t = EST_WaveFile::map.token(type);
EST_sample_type_t values_type = EST_sample_type_map.token(stype);
if (t == wff_none)
{
cerr << "Unknown Wave file type " << type << endl;
return read_error;
}
EST_WaveFile::Load_TokenStream * l_fun = EST_WaveFile::map.info(t).load;
if (l_fun == NULL)
{
cerr << "Can't load waves to files type " << type << endl;
return read_error;
}
return (*l_fun)(ts, *this,
sample_rate, values_type, bov, nc,
offset, length);
}
void EST_Wave::sub_wave(EST_Wave &sw,
int offset, int num,
int start_c, int nchan)
{
if (num == EST_ALL)
num = num_samples()-offset;
if (nchan == EST_ALL)
nchan = num_channels()-start_c;
p_values.sub_matrix(sw.p_values, offset, num, start_c, nchan);
sw.set_sample_rate(sample_rate());
}
EST_write_status EST_Wave::save(const EST_String filename,
const EST_String type)
{
FILE *fp;
if (filename == "-")
fp = stdout;
else if ((fp = fopen(filename,"wb")) == NULL)
{
cerr << "Wave save: can't open output file \"" <<
filename << "\"" << endl;
return write_fail;
}
EST_write_status r = save(fp,type);
if (fp != stdout)
fclose(fp);
return r;
}
EST_write_status EST_Wave::save(FILE *fp, const EST_String type)
{
EST_String save_type = (type == "") ? DEF_FILE_TYPE : type;
EST_WaveFileType t = EST_WaveFile::map.token(save_type);
if (t == wff_none)
{
cerr << "Wave: unknown filetype in saving " << save_type << endl;
return write_fail;
}
EST_WaveFile::Save_TokenStream * s_fun = EST_WaveFile::map.info(t).save;
if (s_fun == NULL)
{
cerr << "Can't save waves to files type " << save_type << endl;
return write_fail;
}
return (*s_fun)(fp, *this, st_short, EST_NATIVE_BO);
}
EST_write_status EST_Wave::save_file(const EST_String filename,
EST_String ftype,
EST_String stype, int obo, const char *mode)
{
FILE *fp;
if (filename == "-")
fp = stdout;
else if ((fp = fopen(filename, mode)) == NULL)
{
cerr << "Wave save: can't open output file \"" <<
filename << "\"" << endl;
return write_fail;
}
EST_write_status r = save_file(fp,ftype,stype,obo);
if (fp != stdout)
fclose(fp);
return r;
}
EST_write_status EST_Wave::save_file(FILE *fp,
EST_String ftype,
EST_String stype, int obo)
{
EST_WaveFileType t = EST_WaveFile::map.token(ftype);
EST_sample_type_t sample_type = EST_sample_type_map.token(stype);
if (t == wff_none)
{
cerr << "Unknown Wave file type " << ftype << endl;
return write_fail;
}
EST_WaveFile::Save_TokenStream * s_fun = EST_WaveFile::map.info(t).save;
if (s_fun == NULL)
{
cerr << "Can't save waves to files type " << ftype << endl;
return write_fail;
}
return (*s_fun)(fp, *this, sample_type, obo);
}
EST_write_status EST_Wave::save_file_data(FILE *fp,
EST_String ftype,
EST_String stype, int obo)
{
EST_WaveFileType t = EST_WaveFile::map.token(ftype);
EST_sample_type_t sample_type = EST_sample_type_map.token(stype);
if (t == wff_none)
{
cerr << "Unknown Wave file type " << ftype << endl;
return write_fail;
}
EST_WaveFile::Save_TokenStream * s_fun = EST_WaveFile::map.info(t).save_data;
if (s_fun == NULL)
{
cerr << "Can't save wave data to files type " << ftype << endl;
return write_fail;
}
return (*s_fun)(fp, *this, sample_type, obo);
}
EST_write_status EST_Wave::save_file_header(FILE *fp,
EST_String ftype,
EST_String stype, int obo)
{
EST_WaveFileType t = EST_WaveFile::map.token(ftype);
EST_sample_type_t sample_type = EST_sample_type_map.token(stype);
if (t == wff_none)
{
cerr << "Unknown Wave file type " << ftype << endl;
return write_fail;
}
EST_WaveFile::Save_TokenStream * s_fun = EST_WaveFile::map.info(t).save_header;
if (s_fun == NULL)
{
cerr << "Can't save wave header to files type " << ftype << endl;
return write_fail;
}
return (*s_fun)(fp, *this, sample_type, obo);
}
void EST_Wave::resample(int new_freq)
{
// Resample wave to new sample rate
if (new_freq != p_sample_rate)
{
if (p_values.rateconv(p_sample_rate, new_freq) != 0)
cerr << "rateconv: failed to convert from " << p_sample_rate <<
" to " << new_freq << "\n";
else
set_sample_rate(new_freq);
}
}
void EST_Wave::compress(float mu, float lim)
{
int x;
for (int i = 0; i < num_samples(); ++i)
{
for (int j = 0; j< num_channels(); ++j)
{
x = a_no_check(i,j);
a_no_check(i,j) = lim * (sgn(x)*(log(1+(mu/lim)*abs(x))/log(1+mu)));
}
}
}
void EST_Wave::rescale(float gain, int normalize)
{
int ns;
float factor = gain;
float nsf;
if (normalize)
{
int max = 0;
for (int i = 0; i < num_samples(); ++i)
for (int j = 0; j < num_channels(); ++j)
if (abs(a_no_check(i,j)) > max)
max = abs(a_no_check(i,j));
if (fabs(max/32766.0-gain) < 0.001)
return; /* already normalized */
else
factor *= 32766.0/(float)max;
}
for (int i = 0; i < num_samples(); ++i)
for (int j = 0; j < num_channels(); ++j)
{
if (factor == 1.0)
ns = a_no_check(i,j); // avoid float fluctuations
else if (factor == -1.0)
ns = -a_no_check(i,j); // avoid float fluctuations
else
{
nsf = (float)a_no_check(i,j) * factor;
if (nsf < 0.0)
ns = (int)(nsf - 0.5);
else
ns = (int)(nsf + 0.5);
}
if (ns < -32766)
a_no_check(i,j)= -32766;
else if (ns > 32766)
a_no_check(i,j)= 32766;
else
a_no_check(i,j)= ns;
}
}
void EST_Wave::rescale( const EST_Track &fc )
{
int ns, start_sample, end_sample;
float target1, target2, increment, factor, nsf;
int fc_length = fc.length();
int _num_channels = num_channels();
cerr << ((int)(fc.t(fc_length-1) * p_sample_rate)) << endl;
if( ((int)(fc.t(fc_length-1) * p_sample_rate)) > num_samples() )
EST_error( "Factor contour track exceeds waveform length (%d samples)",
(fc.t(fc_length-1) * p_sample_rate) - num_samples() );
start_sample = static_cast<unsigned int>( fc.t( 0 )*p_sample_rate );
target1 = fc.a(0,0); // could use separate channels for each waveform channel
for ( int k = 1; k<fc_length; ++k ){
end_sample = static_cast<unsigned int>( fc.t( k )*p_sample_rate );
target2 = fc.a(k);
increment = (target2-target1)/(end_sample-start_sample+1);
factor = target1;
for( int i=start_sample; i<end_sample; ++i, factor+=increment )
for( int j=0; j<_num_channels; ++j ){
if (factor == 1.0)
ns = a_no_check(i,j); // avoid float fluctuations
else if (factor == -1.0)
ns = -a_no_check(i,j); // avoid float fluctuations
else
{
nsf = (float)a_no_check(i,j) * factor;
if (nsf < 0.0)
ns = (int)(nsf - 0.5);
else
ns = (int)(nsf + 0.5);
}
if (ns < -32766)
a_no_check(i,j)= -32766;
else if (ns > 32766)
a_no_check(i,j)= 32766;
else
a_no_check(i,j)= ns;
}
start_sample = end_sample;
target1 = target2;
}
}
EST_Wave &EST_Wave::operator =(const EST_Wave &w)
{
copy(w);
return *this;
}
EST_Wave &EST_Wave::operator +=(const EST_Wave &w)
{
EST_Wave w2;
const EST_Wave *toadd = &w;
if (w.num_channels() != num_channels())
{
cerr << "Cannot concatenate waveforms with differing numbers of channels\n";
return *this;
}
if (p_sample_rate != w.sample_rate())
{
w2 = w;
w2.resample(p_sample_rate);
toadd= &w2;
}
p_values.add_rows(toadd->p_values);
return *this;
}
// add wave p_values to existing wave in parallel to create multi-channel wave.
EST_Wave &EST_Wave::operator |=(const EST_Wave &wi)
{
int i, k;
EST_Wave w = wi; // to allow resampling of const
w.resample(p_sample_rate); // far too difficult otherwise
int o_channels = num_channels();
int r_channels = num_channels()+w.num_channels();
int r_samples = Gof(num_samples(), w.num_samples());
resize(r_samples, r_channels);
for (k = 0; k < w.num_channels(); ++k)
for (i=0; i < w.num_samples(); i++)
a(i,k+o_channels) += w.a(i, k);
return *this;
}
ostream& operator << (ostream& p_values, const EST_Wave &sig)
{
for (int i = 0; i < sig.num_samples(); ++i)
p_values << sig(i) << "\n";
return p_values;
}
int operator != (EST_Wave a, EST_Wave b)
{ (void)a; (void)b; return 1; }
int operator == (EST_Wave a, EST_Wave b)
{ (void)a; (void)b; return 0; }
EST_String
Definition EST_String.h:70
EST_TMatrix::fill
void fill(const T &v)
fill matrix with value v
Definition EST_TMatrix.cc:314
EST_TSimpleMatrix::resize
void resize(int rows, int cols, int set=1)
resize matrix
Definition EST_TSimpleMatrix.cc:86
EST_TokenStream
Definition EST_Token.h:235
EST_TokenStream::close
void close(void)
Close stream.
Definition EST_Token.cc:406
EST_TokenStream::tell
int tell(void) const
tell, synonym for filepos
Definition EST_Token.h:363
EST_TokenStream::open
int open(const EST_String &filename)
open a \Ref{EST_TokenStream} for a file.
Definition EST_Token.cc:200
EST_TokenStream::seek
int seek(int position)
seek, reposition file pointer
Definition EST_Token.cc:305
EST_Track
Definition EST_Track.h:89
EST_Track::t
float & t(int i=0)
return time position of frame i
Definition EST_Track.h:477
EST_Track::a
float & a(int i, int c=0)
Definition EST_Track.cc:1022
EST_Track::length
int length() const
return number of frames in track
Definition EST_Track.h:653
EST_Wave
Definition EST_Wave.h:65
EST_Wave::load_file
EST_read_status load_file(const EST_String filename, const EST_String filetype, int sample_rate, const EST_String sample_type, int bo, int nc, int offset=0, int length=0)
Definition EST_Wave.cc:288
EST_Wave::a
short & a(int i, int channel=0)
Definition EST_Wave.cc:128
EST_Wave::num_channels
int num_channels() const
return the number of channels in the waveform
Definition EST_Wave.h:145
EST_Wave::length
int length() const
return the size of the waveform, i.e. the number of samples.
Definition EST_Wave.h:151
EST_Wave::a_safe
short & a_safe(int i, int channel=0)
Definition EST_Wave.cc:152
EST_Wave::operator=
EST_Wave & operator=(const EST_Wave &w)
Assignment operator.
Definition EST_Wave.cc:612
EST_Wave::compress
void compress(float mu, float limit)
Dynamic Range Compression - SaiKrishna May 2017.
Definition EST_Wave.cc:503
EST_Wave::sample_rate
int sample_rate() const
return the sampling rate (frequency)
Definition EST_Wave.h:147
EST_Wave::load
EST_read_status load(const EST_String filename, int offset=0, int length=0, int rate=default_sample_rate)
Definition EST_Wave.cc:180
EST_Wave::resample
void resample(int rate)
Resample waveform to rate.
Definition EST_Wave.cc:489
EST_Wave::resize
void resize(int num_samples, int num_channels=EST_ALL, int set=1)
resize the waveform
Definition EST_Wave.h:184
EST_Wave::operator|=
EST_Wave & operator|=(const EST_Wave &a)
Definition EST_Wave.cc:642
EST_Wave::t
float t(int i) const
return the time position in seconds of the ith sample
Definition EST_Wave.h:137
EST_Wave::rescale
void rescale(float gain, int normalize=0)
Definition EST_Wave.cc:517
EST_Wave::EST_Wave
EST_Wave()
default constructor
Definition EST_Wave.cc:63
EST_Wave::sample_type
EST_String sample_type() const
Definition EST_Wave.h:163
EST_Wave::operator+=
EST_Wave & operator+=(const EST_Wave &a)
Definition EST_Wave.cc:618
EST_Wave::num_samples
int num_samples() const
return the number of samples in the waveform
Definition EST_Wave.h:143
EST_Wave::set_sample_rate
void set_sample_rate(const int n)
Set sampling rate to n.
Definition EST_Wave.h:149