ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity

Add libzita-resampler as lib 

This simplifies x-compiling and x-platform builds as well
allows to statically link, if needed.
This commit is contained in:
Robin Gareus 2017-09-16 15:34:11 +02:00
parent f53cec1d8f
commit eb71eddbc8
11 changed files with 1181 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
libs/zita-resampler/cresampler.cc Normal file
View File

@ -0,0 +1,177 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2013 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "zita-resampler/cresampler.h"
using namespace ArdourZita;
CResampler::CResampler (void)
: _nchan (0)
, _buff (0)
{
reset ();
}
CResampler::~CResampler (void)
{
clear ();
}
int
CResampler::setup (double ratio,
unsigned int nchan)
{
if (! nchan) return 1;
clear ();
_inmax = 50;
_buff = new float [nchan * (3 + _inmax)];
_nchan = nchan;
_pstep = 1 / ratio;
return reset ();
}
void
CResampler::clear (void)
{
delete[] _buff;
_buff = 0;
_nchan = 0;
_inmax = 0;
_pstep = 0;
reset ();
}
void
CResampler::set_phase (double p)
{
_phase = p - floor (p);
}
void
CResampler::set_ratio (double r)
{
_pstep = 1.0 / r;
}
double
CResampler::inpdist (void) const
{
return (int)(3 - _nread) - _phase;
}
int
CResampler::inpsize (void) const
{
return 4;
}
int
CResampler::reset (void)
{
inp_count = 0;
out_count = 0;
inp_data = 0;
out_data = 0;
_index = 0;
_phase = 0;
_nread = 4;
_nzero = 0;
return 0;
}
int
CResampler::process (void)
{
unsigned int in, nr, n, c;
int nz;
double ph;
float *pb, a, b, d, m0, m1, m2, m3;
in = _index;
nr = _nread;
nz = _nzero;
ph = _phase;
pb = _buff + in * _nchan;
while (out_count) {
if (nr) {
if (inp_count == 0) break;
n = (4 - nr) * _nchan;
if (inp_data) {
for (c = 0; c < _nchan; c++) pb [n + c] = inp_data [c];
inp_data += _nchan;
nz = 0;
} else {
for (c = 0; c < _nchan; c++) pb [n + c] = 0;
if (nz < 4) nz++;
}
nr--;
inp_count--;
} else {
n = _nchan;
if (out_data) {
if (nz < 4) {
a = ph;
b = 1 - a;
d = a * b / 2;
m0 = -d * b;
m1 = b + (3 * b - 1) * d;
m2 = a + (3 * a - 1) * d;
m3 = -d * a;
for (c = 0; c < n; c++) {
*out_data++ = m0 * pb [0]
+ m1 * pb [n]
+ m2 * pb [2 * n]
+ m3 * pb [3 * n];
pb++;
}
pb -= n;
} else {
for (c = 0; c < n; c++) *out_data++ = 0;
}
}
out_count--;
ph += _pstep;
if (ph >= 1.0) {
nr = (unsigned int) floor (ph);
ph -= nr;
in += nr;
pb += nr * _nchan;
if (in >= _inmax) {
memcpy (_buff, pb, (4 - nr) * _nchan * sizeof (float));
in = 0;
pb = _buff;
}
}
}
}
_index = in;
_nread = nr;
_nzero = nz;
_phase = ph;
return 0;
}

123
libs/zita-resampler/resampler-table.cc Normal file
View File

@ -0,0 +1,123 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "zita-resampler/resampler-table.h"
using namespace ArdourZita;
Resampler_table *Resampler_table::_list = 0;
Resampler_mutex Resampler_table::_mutex;
static double sinc (double x)
{
x = fabs (x);
if (x < 1e-6) return 1.0;
x *= M_PI;
return sin (x) / x;
}
static double wind (double x)
{
x = fabs (x);
if (x >= 1.0) return 0.0f;
x *= M_PI;
return 0.384 + 0.500 * cos (x) + 0.116 * cos (2 * x);
}
Resampler_table::Resampler_table (double fr, unsigned int hl, unsigned int np)
: _next (0)
, _refc (0)
, _fr (fr)
, _hl (hl)
, _np (np)
{
unsigned int i, j;
double t;
float *p;
_ctab = new float [hl * (np + 1)];
p = _ctab;
for (j = 0; j <= np; j++) {
t = (double) j / (double) np;
for (i = 0; i < hl; i++) {
p [hl - i - 1] = (float)(fr * sinc (t * fr) * wind (t / hl));
t += 1;
}
p += hl;
}
}
Resampler_table::~Resampler_table (void)
{
delete[] _ctab;
}
Resampler_table*
Resampler_table::create (double fr, unsigned int hl, unsigned int np)
{
Resampler_table *P;
_mutex.lock ();
P = _list;
while (P) {
if ((fr >= P->_fr * 0.999) && (fr <= P->_fr * 1.001) && (hl == P->_hl) && (np == P->_np)) {
P->_refc++;
_mutex.unlock ();
return P;
}
P = P->_next;
}
P = new Resampler_table (fr, hl, np);
P->_refc = 1;
P->_next = _list;
_list = P;
_mutex.unlock ();
return P;
}
void
Resampler_table::destroy (Resampler_table *T)
{
Resampler_table *P, *Q;
_mutex.lock ();
if (T) {
T->_refc--;
if (T->_refc == 0) {
P = _list;
Q = 0;
while (P) {
if (P == T) {
if (Q) Q->_next = T->_next;
else _list = T->_next;
break;
}
Q = P;
P = P->_next;
}
delete T;
}
}
_mutex.unlock ();
}

236
libs/zita-resampler/resampler.cc Normal file
View File

@ -0,0 +1,236 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "zita-resampler/resampler.h"
using namespace ArdourZita;
static unsigned int gcd (unsigned int a, unsigned int b)
{
if (a == 0) return b;
if (b == 0) return a;
while (1) {
if (a > b) {
a = a % b;
if (a == 0) return b;
if (a == 1) return 1;
} else {
b = b % a;
if (b == 0) return a;
if (b == 1) return 1;
}
}
return 1;
}
Resampler::Resampler (void)
: _table (0)
, _nchan (0)
, _buff (0)
{
reset ();
}
Resampler::~Resampler (void)
{
clear ();
}
int
Resampler::setup (unsigned int fs_inp,
unsigned int fs_out,
unsigned int nchan,
unsigned int hlen)
{
if ((hlen < 8) || (hlen > 96)) return 1;
return setup (fs_inp, fs_out, nchan, hlen, 1.0 - 2.6 / hlen);
}
int
Resampler::setup (unsigned int fs_inp,
unsigned int fs_out,
unsigned int nchan,
unsigned int hlen,
double frel)
{
unsigned int g, h, k, n, s;
double r;
float *B = 0;
Resampler_table *T = 0;
k = s = 0;
if (fs_inp && fs_out && nchan) {
r = (double) fs_out / (double) fs_inp;
g = gcd (fs_out, fs_inp);
n = fs_out / g;
s = fs_inp / g;
if ((16 * r >= 1) && (n <= 1000)) {
h = hlen;
k = 250;
if (r < 1) {
frel *= r;
h = (unsigned int)(ceil (h / r));
k = (unsigned int)(ceil (k / r));
}
T = Resampler_table::create (frel, h, n);
B = new float [nchan * (2 * h - 1 + k)];
}
}
clear ();
if (T) {
_table = T;
_buff = B;
_nchan = nchan;
_inmax = k;
_pstep = s;
return reset ();
}
else return 1;
}
void
Resampler::clear (void)
{
Resampler_table::destroy (_table);
delete[] _buff;
_buff = 0;
_table = 0;
_nchan = 0;
_inmax = 0;
_pstep = 0;
reset ();
}
double
Resampler::inpdist (void) const
{
if (!_table) return 0;
return (int)(_table->_hl + 1 - _nread) - (double)_phase / _table->_np;
}
int
Resampler::inpsize (void) const
{
if (!_table) return 0;
return 2 * _table->_hl;
}
int
Resampler::reset (void)
{
if (!_table) return 1;
inp_count = 0;
out_count = 0;
inp_data = 0;
out_data = 0;
_index = 0;
_nread = 0;
_nzero = 0;
_phase = 0;
if (_table) {
_nread = 2 * _table->_hl;
return 0;
}
return 1;
}
int
Resampler::process (void)
{
unsigned int hl, ph, np, dp, in, nr, nz, i, n, c;
float *p1, *p2;
if (!_table) return 1;
hl = _table->_hl;
np = _table->_np;
dp = _pstep;
in = _index;
nr = _nread;
ph = _phase;
nz = _nzero;
n = (2 * hl - nr) * _nchan;
p1 = _buff + in * _nchan;
p2 = p1 + n;
while (out_count) {
if (nr) {
if (inp_count == 0) break;
if (inp_data) {
for (c = 0; c < _nchan; c++) p2 [c] = inp_data [c];
inp_data += _nchan;
nz = 0;
} else {
for (c = 0; c < _nchan; c++) p2 [c] = 0;
if (nz < 2 * hl) nz++;
}
nr--;
p2 += _nchan;
inp_count--;
} else {
if (out_data) {
if (nz < 2 * hl) {
float *c1 = _table->_ctab + hl * ph;
float *c2 = _table->_ctab + hl * (np - ph);
for (c = 0; c < _nchan; c++) {
float *q1 = p1 + c;
float *q2 = p2 + c;
float s = 1e-20f;
for (i = 0; i < hl; i++) {
q2 -= _nchan;
s += *q1 * c1 [i] + *q2 * c2 [i];
q1 += _nchan;
}
*out_data++ = s - 1e-20f;
}
} else {
for (c = 0; c < _nchan; c++) *out_data++ = 0;
}
}
out_count--;
ph += dp;
if (ph >= np) {
nr = ph / np;
ph -= nr * np;
in += nr;
p1 += nr * _nchan;;
if (in >= _inmax) {
n = (2 * hl - nr) * _nchan;
memcpy (_buff, p1, n * sizeof (float));
in = 0;
p1 = _buff;
p2 = p1 + n;
}
}
}
}
_index = in;
_nread = nr;
_phase = ph;
_nzero = nz;
return 0;
}

253
libs/zita-resampler/vresampler.cc Normal file
View File

@ -0,0 +1,253 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2006-2013 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "zita-resampler/vresampler.h"
using namespace ArdourZita;
VResampler::VResampler (void)
: _table (0)
, _nchan (0)
, _buff (0)
, _c1 (0)
, _c2 (0)
{
reset ();
}
VResampler::~VResampler (void)
{
clear ();
}
int
VResampler::setup (double ratio,
unsigned int nchan,
unsigned int hlen)
{
if ((hlen < 8) || (hlen > 96) || (16 * ratio < 1) || (ratio > 256)) return 1;
return setup (ratio, nchan, hlen, 1.0 - 2.6 / hlen);
}
int
VResampler::setup (double ratio,
unsigned int nchan,
unsigned int hlen,
double frel)
{
unsigned int h, k, n;
double s;
Resampler_table *T = 0;
if (! nchan) return 1;
n = NPHASE;
s = n / ratio;
h = hlen;
k = 250;
if (ratio < 1) {
frel *= ratio;
h = (unsigned int)(ceil (h / ratio));
k = (unsigned int)(ceil (k / ratio));
}
T = Resampler_table::create (frel, h, n);
clear ();
if (T) {
_table = T;
_buff = new float [nchan * (2 * h - 1 + k)];
_c1 = new float [2 * h];
_c2 = new float [2 * h];
_nchan = nchan;
_inmax = k;
_ratio = ratio;
_pstep = s;
_qstep = s;
_wstep = 1;
return reset ();
}
else return 1;
}
void
VResampler::clear (void)
{
Resampler_table::destroy (_table);
delete[] _buff;
delete[] _c1;
delete[] _c2;
_buff = 0;
_c1 = 0;
_c2 = 0;
_table = 0;
_nchan = 0;
_inmax = 0;
_pstep = 0;
_qstep = 0;
_wstep = 1;
reset ();
}
void
VResampler::set_phase (double p)
{
if (!_table) return;
_phase = (p - floor (p)) * _table->_np;
}
void
VResampler::set_rrfilt (double t)
{
if (!_table) return;
_wstep = (t < 1) ? 1 : 1 - exp (-1 / t);
}
void
VResampler::set_rratio (double r)
{
if (!_table) return;
if (r > 16.0) r = 16.0;
if (r < 0.95) r = 0.95;
_qstep = _table->_np / (_ratio * r);
}
double
VResampler::inpdist (void) const
{
if (!_table) return 0;
return (int)(_table->_hl + 1 - _nread) - _phase / _table->_np;
}
int
VResampler::inpsize (void) const
{
if (!_table) return 0;
return 2 * _table->_hl;
}
int
VResampler::reset (void)
{
if (!_table) return 1;
inp_count = 0;
out_count = 0;
inp_data = 0;
out_data = 0;
_index = 0;
_phase = 0;
_nread = 2 * _table->_hl;
_nzero = 0;
return 0;
}
int
VResampler::process (void)
{
unsigned int k, np, in, nr, n, c;
int i, hl, nz;
double ph, dp, dd;
float a, b, *p1, *p2, *q1, *q2;
if (!_table) return 1;
hl = _table->_hl;
np = _table->_np;
in = _index;
nr = _nread;
nz = _nzero;
ph = _phase;
dp = _pstep;
n = (2 * hl - nr) * _nchan;
p1 = _buff + in * _nchan;
p2 = p1 + n;
while (out_count) {
if (nr) {
if (inp_count == 0) break;
if (inp_data) {
for (c = 0; c < _nchan; c++) p2 [c] = inp_data [c];
inp_data += _nchan;
nz = 0;
} else {
for (c = 0; c < _nchan; c++) p2 [c] = 0;
if (nz < 2 * hl) nz++;
}
nr--;
p2 += _nchan;
inp_count--;
} else {
if (out_data) {
if (nz < 2 * hl) {
k = (unsigned int) ph;
b = (float)(ph - k);
a = 1.0f - b;
q1 = _table->_ctab + hl * k;
q2 = _table->_ctab + hl * (np - k);
for (i = 0; i < hl; i++) {
_c1 [i] = a * q1 [i] + b * q1 [i + hl];
_c2 [i] = a * q2 [i] + b * q2 [i - hl];
}
for (c = 0; c < _nchan; c++) {
q1 = p1 + c;
q2 = p2 + c;
a = 1e-25f;
for (i = 0; i < hl; i++) {
q2 -= _nchan;
a += *q1 * _c1 [i] + *q2 * _c2 [i];
q1 += _nchan;
}
*out_data++ = a - 1e-25f;
}
} else {
for (c = 0; c < _nchan; c++) *out_data++ = 0;
}
}
out_count--;
dd = _qstep - dp;
if (fabs (dd) < 1e-30) dp = _qstep;
else dp += _wstep * dd;
ph += dp;
if (ph >= np) {
nr = (unsigned int) floor( ph / np);
ph -= nr * np;;
in += nr;
p1 += nr * _nchan;;
if (in >= _inmax) {
n = (2 * hl - nr) * _nchan;
memcpy (_buff, p1, n * sizeof (float));
in = 0;
p1 = _buff;
p2 = p1 + n;
}
}
}
}
_index = in;
_nread = nr;
_phase = ph;
_pstep = dp;
_nzero = nz;
return 0;
}

62
libs/zita-resampler/wscript Normal file
View File

@ -0,0 +1,62 @@
#!/usr/bin/env python
from waflib.extras import autowaf as autowaf
from waflib import Options
from waflib import TaskGen
import os
# Version of this package (even if built as a child)
MAJOR = '1'
MINOR = '6'
MICRO = '0'
ZRESAMPLER_VERSION = "%s.%s.%s" % (MAJOR, MINOR, MICRO)
# Library version (UNIX style major, minor, micro)
# major increment <=> incompatible changes
# minor increment <=> compatible changes (additions)
# micro increment <=> no interface changes
ZRESAMPLER_LIB_VERSION = '1.6.0'
# Variables for 'waf dist'
APPNAME = 'zita-resampler'
VERSION = ZRESAMPLER_VERSION
I18N_PACKAGE = 'libzita-resampler'
# Mandatory variables
top = '.'
out = 'build'
zresampler_sources = [
'resampler.cc',
'resampler-table.cc',
'cresampler.cc',
'vresampler.cc',
]
def options(opt):
autowaf.set_options(opt)
def configure(conf):
if conf.is_defined('USE_EXTERNAL_LIBS'):
autowaf.check_pkg(conf, 'zita-reampler', uselib_store='LIBZRESAMPLER', atleast_version=ZRESAMPLER_LIB_VERSION, mandatory=True)
else:
conf.load ('compiler_cxx')
autowaf.configure(conf)
def build(bld):
if bld.is_defined('USE_EXTERNAL_LIBS'):
return
obj = bld.stlib(features = 'cxx cxxstlib', source = zresampler_sources)
obj.cxxflags = [ '-fPIC' ]
obj.cflags = [ '-fPIC' ]
obj.export_includes = ['.']
obj.includes = ['.']
obj.name = 'zita-resampler'
obj.target = 'zita-resampler'
obj.vnum = ZRESAMPLER_LIB_VERSION
obj.install_path = bld.env['LIBDIR']
obj.defines = [ 'PACKAGE="' + I18N_PACKAGE + '"' ]
def shutdown():
autowaf.shutdown()

66
libs/zita-resampler/zita-resampler/cresampler.h Normal file
View File

@ -0,0 +1,66 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2013 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#ifndef _ZITA_CRESAMPLER_H_
#define _ZITA_CRESAMPLER_H_
#include "zita-resampler/zresampler_visibility.h"
namespace ArdourZita {
class LIBZRESAMPLER_API CResampler
{
public:
CResampler (void);
~CResampler (void);
int setup (double ratio, unsigned int nchan);
void clear (void);
int reset (void);
int nchan (void) const { return _nchan; }
int inpsize (void) const;
double inpdist (void) const;
int process (void);
void set_ratio (double r);
void set_phase (double p);
unsigned int inp_count;
unsigned int out_count;
float *inp_data;
float *out_data;
void *inp_list;
void *out_list;
private:
unsigned int _nchan;
unsigned int _inmax;
unsigned int _index;
unsigned int _nread;
unsigned int _nzero;
double _phase;
double _pstep;
float *_buff;
};
};
#endif

69
libs/zita-resampler/zita-resampler/resampler-table.h Normal file
View File

@ -0,0 +1,69 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#ifndef _ZITA_RESAMPLER_TABLE_H_
#define _ZITA_RESAMPLER_TABLE_H_
#include <pthread.h>
#include "zita-resampler/zresampler_visibility.h"
namespace ArdourZita {
class LIBZRESAMPLER_API Resampler_mutex
{
private:
friend class Resampler_table;
Resampler_mutex (void) { pthread_mutex_init (&_mutex, 0); }
~Resampler_mutex (void) { pthread_mutex_destroy (&_mutex); }
void lock (void) { pthread_mutex_lock (&_mutex); }
void unlock (void) { pthread_mutex_unlock (&_mutex); }
pthread_mutex_t _mutex;
};
class LIBZRESAMPLER_API Resampler_table
{
private:
Resampler_table (double fr, unsigned int hl, unsigned int np);
~Resampler_table (void);
friend class Resampler;
friend class VResampler;
Resampler_table *_next;
unsigned int _refc;
float *_ctab;
double _fr;
unsigned int _hl;
unsigned int _np;
static Resampler_table *create (double fr, unsigned int hl, unsigned int np);
static void destroy (Resampler_table *T);
static Resampler_table *_list;
static Resampler_mutex _mutex;
};
};
#endif

78
libs/zita-resampler/zita-resampler/resampler.h Normal file
View File

@ -0,0 +1,78 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#ifndef _ZITA_RESAMPLER_H_
#define _ZITA_RESAMPLER_H_
#include "zita-resampler/zresampler_visibility.h"
#include "zita-resampler/resampler-table.h"
namespace ArdourZita {
class LIBZRESAMPLER_API Resampler
{
public:
Resampler (void);
~Resampler (void);
int setup (unsigned int fs_inp,
unsigned int fs_out,
unsigned int nchan,
unsigned int hlen);
int setup (unsigned int fs_inp,
unsigned int fs_out,
unsigned int nchan,
unsigned int hlen,
double frel);
void clear (void);
int reset (void);
int nchan (void) const { return _nchan; }
int inpsize (void) const;
double inpdist (void) const;
int process (void);
unsigned int inp_count;
unsigned int out_count;
float *inp_data;
float *out_data;
void *inp_list;
void *out_list;
private:
Resampler_table *_table;
unsigned int _nchan;
unsigned int _inmax;
unsigned int _index;
unsigned int _nread;
unsigned int _nzero;
unsigned int _phase;
unsigned int _pstep;
float *_buff;
void *_dummy [8];
};
};
#endif

84
libs/zita-resampler/zita-resampler/vresampler.h Normal file
View File

@ -0,0 +1,84 @@
// ----------------------------------------------------------------------------
//
// Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
//
// 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.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
#ifndef _ZITA_VRESAMPLER_H_
#define _ZITA_VRESAMPLER_H_
#include "zita-resampler/zresampler_visibility.h"
#include "zita-resampler/resampler-table.h"
namespace ArdourZita {
class LIBZRESAMPLER_API VResampler
{
public:
VResampler (void);
~VResampler (void);
int setup (double ratio,
unsigned int nchan,
unsigned int hlen);
int setup (double ratio,
unsigned int nchan,
unsigned int hlen,
double frel);
void clear (void);
int reset (void);
int nchan (void) const { return _nchan; }
int inpsize (void) const;
double inpdist (void) const;
int process (void);
void set_phase (double p);
void set_rrfilt (double t);
void set_rratio (double r);
unsigned int inp_count;
unsigned int out_count;
float *inp_data;
float *out_data;
void *inp_list;
void *out_list;
private:
enum { NPHASE = 256 };
Resampler_table *_table;
unsigned int _nchan;
unsigned int _inmax;
unsigned int _index;
unsigned int _nread;
unsigned int _nzero;
double _ratio;
double _phase;
double _pstep;
double _qstep;
double _wstep;
float *_buff;
float *_c1;
float *_c2;
void *_dummy [8];
};
};
#endif

32
libs/zita-resampler/zita-resampler/zresampler_visibility.h Normal file
View File

@ -0,0 +1,32 @@
#ifndef __libzreampler_visibility_h__
#define __libzreampler_visibility_h__
#if defined(COMPILER_MSVC)
#define LIBZRESAMPLER_DLL_IMPORT __declspec(dllimport)
#define LIBZRESAMPLER_DLL_EXPORT __declspec(dllexport)
#define LIBZRESAMPLER_DLL_LOCAL
#else
#define LIBZRESAMPLER_DLL_IMPORT __attribute__ ((visibility ("default")))
#define LIBZRESAMPLER_DLL_EXPORT __attribute__ ((visibility ("default")))
#define LIBZRESAMPLER_DLL_LOCAL __attribute__ ((visibility ("hidden")))
#endif
#ifdef LIBZRESAMPLER_STATIC // libzita-reampler is a DLL
#define LIBZRESAMPLER_API
#define LIBZRESAMPLER_LOCAL
#define LIBZRESAMPLER_TEMPLATE_API
#define LIBZRESAMPLER_TEMPLATE_MEMBER_API
#else
#ifdef LIBZRESAMPLER_DLL_EXPORTS // defined if we are building the libzita-resampler DLL (instead of using it)
#define LIBZRESAMPLER_API LIBZRESAMPLER_DLL_EXPORT
#define LIBZRESAMPLER_TEMPLATE_API LIBZRESAMPLER_TEMPLATE_DLL_EXPORT
#define LIBZRESAMPLER_TEMPLATE_MEMBER_API LIBZRESAMPLER_TEMPLATE_MEMBER_DLL_EXPORT
#else
#define LIBZRESAMPLER_API LIBZRESAMPLER_DLL_IMPORT
#define LIBZRESAMPLER_TEMPLATE_API LIBZRESAMPLER_TEMPLATE_DLL_IMPORT
#define LIBZRESAMPLER_TEMPLATE_MEMBER_API LIBZRESAMPLER_TEMPLATE_MEMBER_DLL_IMPORT
#endif
#define LIBZRESAMPLER_LOCAL LIBZRESAMPLER_DLL_LOCAL
#endif
#endif

1
wscript
View File

@ -225,6 +225,7 @@ children = [
'libs/ptformat',
'libs/qm-dsp',
'libs/vamp-plugins',
'libs/zita-resampler',
# core ardour libraries
'libs/pbd',
'libs/midi++2',