Browse Source

Timeline: Read interleaved blocks of samples from libsndfile, rather than processing one channel at a time.

tags/non-daw-v1.2.0
Jonathan Moore Liles 10 years ago
parent
commit
2afec38a54
6 changed files with 157 additions and 62 deletions
  1. +33
    -0
      nonlib/dsp.C
  2. +2
    -0
      nonlib/dsp.h
  3. +4
    -2
      timeline/src/Audio_Region.H
  4. +107
    -39
      timeline/src/Engine/Audio_Region.C
  5. +10
    -19
      timeline/src/Engine/Audio_Sequence.C
  6. +1
    -2
      timeline/src/Engine/Playback_DS.C

+ 33
- 0
nonlib/dsp.C View File

@@ -136,6 +136,39 @@ buffer_deinterleave_one_channel ( sample_t * __restrict__ dst, const sample_t *
}
}

void
buffer_interleaved_mix ( sample_t *__restrict__ dst, const sample_t * __restrict__ src, int dst_channel, int src_channel, int dst_channels, int src_channels, nframes_t nframes )
{
sample_t * dst_ = (sample_t*) assume_aligned(dst);
const sample_t * src_ = (const sample_t*) assume_aligned(src);

dst_ += dst_channel;
src_ += src_channel;

while ( nframes-- )
{
*dst_ += *src_;
dst_ += dst_channels;
src_ += src_channels;
}
}

void
buffer_interleaved_copy ( sample_t *__restrict__ dst, const sample_t * __restrict__ src, int dst_channel, int src_channel, int dst_channels, int src_channels, nframes_t nframes )
{
sample_t * dst_ = (sample_t*) assume_aligned(dst);
const sample_t * src_ = (const sample_t*) assume_aligned(src);

dst_ += dst_channel;
src_ += src_channel;

while ( nframes-- )
{
*dst_ = *src_;
dst_ += dst_channels;
src_ += src_channels;
}
}

void
buffer_fill_with_silence ( sample_t *buf, nframes_t nframes )


+ 2
- 0
nonlib/dsp.h View File

@@ -33,6 +33,8 @@ void buffer_mix_with_gain ( sample_t *dst, const sample_t *src, nframes_t nframe
void buffer_interleave_one_channel ( sample_t *dst, const sample_t *src, int channel, int channels, nframes_t nframes );
void buffer_interleave_one_channel_and_mix ( sample_t *dst, const sample_t *src, int channel, int channels, nframes_t nframes );
void buffer_deinterleave_one_channel ( sample_t *dst, const sample_t *src, int channel, int channels, nframes_t nframes );
void buffer_interleaved_mix ( sample_t *__restrict__ dst, const sample_t * __restrict__ src, int dst_channel, int src_channel, int dst_channels, int src_channels, nframes_t nframes );
void buffer_interleaved_copy ( sample_t *__restrict__ dst, const sample_t * __restrict__ src, int dst_channel, int src_channel, int dst_channels, int src_channels, nframes_t nframes );
void buffer_fill_with_silence ( sample_t *buf, nframes_t nframes );
bool buffer_is_digital_black ( const sample_t *buf, nframes_t nframes );
float buffer_get_peak ( const sample_t *buf, nframes_t nframes );


+ 4
- 2
timeline/src/Audio_Region.H View File

@@ -88,7 +88,9 @@ public:
}

void apply ( sample_t *buf, fade_dir_e dir, nframes_t start, nframes_t nframes ) const;
};
void apply_interleaved ( sample_t *buf, fade_dir_e dir, nframes_t start, nframes_t nframes, int channels ) const;
};

/* struct Fade_In : public Fade; */
/* struct Fade_Out : public Fade; */
@@ -166,7 +168,7 @@ public:

virtual Fl_Color actual_box_color ( void ) const;
/* Engine */
nframes_t read ( sample_t *buf, nframes_t pos, nframes_t nframes, int channel ) const;
nframes_t read ( sample_t *buf, bool buf_is_empty, nframes_t pos, nframes_t nframes, int out_channels ) const;
nframes_t write ( nframes_t nframes );
void prepare ( void );
bool finalize ( nframes_t frame );


+ 107
- 39
timeline/src/Engine/Audio_Region.C View File

@@ -57,19 +57,46 @@ Audio_Region::Fade::apply ( sample_t *buf, Audio_Region::Fade::fade_dir_e dir, n
*(buf++) *= gain( fi );
}

/** read the overlapping part of /channel/ at /pos/ for /nframes/ of
this region into /buf/, where /pos/ is in timeline frames */
void
Audio_Region::Fade::apply_interleaved ( sample_t *buf, Audio_Region::Fade::fade_dir_e dir, nframes_t start, nframes_t nframes, int channels ) const
{
// printf( "apply fade %s: start=%ld end=%lu\n", dir == Fade::Out ? "out" : "in", start, end );
if ( ! nframes )
return;

nframes_t n = nframes;

const double inc = increment();
double fi = start / (double)length;

if ( dir == Fade::Out )
{
fi = 1.0f - fi;
for ( ; n--; fi -= inc )
{
const float g = gain(fi);

for ( int i = channels; i--; )
*(buf++) *= g;
}
}
else
for ( ; n--; fi += inc )
{
const float g = gain(fi);

for ( int i = channels; i--; )
*(buf++) *= g;
}
}


/** read the overlapping at /pos/ for /nframes/ of this region into
/buf/, where /pos/ is in timeline frames. /buf/ is an interleaved
buffer of /channels/ channels */
/* this runs in the diskstream thread. */
/* FIXME: it is far more efficient to read all the channels from a
multichannel source at once... But how should we handle the case of a
mismatch between the number of channels in this region's source and
the number of channels on the track/buffer this data is being read
for? Would it not be better to simply buffer and deinterlace the
frames in the Audio_File class instead, so that sequential requests
for different channels at the same position avoid hitting the disk
again? */
nframes_t
Audio_Region::read ( sample_t *buf, nframes_t pos, nframes_t nframes, int channel ) const
Audio_Region::read ( sample_t *buf, bool buf_is_empty, nframes_t pos, nframes_t nframes, int channels ) const
{
THREAD_ASSERT( Playback );

@@ -79,6 +106,20 @@ Audio_Region::read ( sample_t *buf, nframes_t pos, nframes_t nframes, int channe
if ( pos > r.start + r.length || pos + nframes < r.start )
return 0;

sample_t *cbuf = NULL;

if ( buf_is_empty && channels == _clip->channels() )
{
/* in this case we don't need a temp buffer */
cbuf = buf;
}
else
{
/* temporary buffer to hold interleaved samples from the clip */
cbuf = buffer_alloc( _clip->channels() * nframes );
memset(cbuf, 0, _clip->channels() * sizeof(sample_t) * nframes );
}

/* calculate offsets into file and sample buffer */

nframes_t sofs, /* offset into source */
@@ -101,50 +142,56 @@ Audio_Region::read ( sample_t *buf, nframes_t pos, nframes_t nframes, int channe
sofs = pos - r.start;
}

if ( ofs >= nframes )
return 0;

// const nframes_t start = ofs + r.start + sofs;
const nframes_t start = r.offset + sofs;
const nframes_t len = cnt;

/* FIXME: keep the declick defults someplace else */
Fade declick;

declick.length = (float)timeline->sample_rate() * 0.01f;
declick.type = Fade::Sigmoid;

if ( ofs >= nframes )
{
cnt = 0;
goto done;
}

if ( len == 0 )
return 0;
{
cnt = 0;
goto done;
}

/* now that we know how much and where to read, get on with it */

// printf( "reading region ofs = %lu, sofs = %lu, %lu-%lu\n", ofs, sofs, start, end );

/* FIXME: keep the declick defults someplace else */
Fade declick;

declick.length = 256;
declick.type = Fade::Sigmoid;

if ( _loop )
{
nframes_t lofs = sofs % _loop;
nframes_t lstart = r.offset + lofs;

/* read interleaved channels */
if ( lofs + len > _loop )
{
/* this buffer covers a loop binary */
/* this buffer covers a loop boundary */

/* read the first part */
cnt = _clip->read( buf + ofs, channel, lstart, len - ( ( lofs + len ) - _loop ) );
cnt = _clip->read( cbuf + ( _clip->channels() * ofs ), -1, lstart, len - ( ( lofs + len ) - _loop ) );
/* read the second part */
cnt += _clip->read( buf + ofs + cnt, channel, lstart + cnt, len - cnt );

/* TODO: declick/crossfade transition? */
cnt += _clip->read( cbuf + ( _clip->channels() * ( ofs + cnt ) ), -1, lstart + cnt, len - cnt );

assert( cnt == len );
}
else
cnt = _clip->read( buf + ofs, channel, lstart, len );
cnt = _clip->read( cbuf + ( channels * ofs ), -1, lstart, len );

/* this buffer is inside declicking proximity to the loop boundary */
if ( lofs + cnt + declick.length > _loop /* buffer ends within declick length of the end of loop */
&&
sofs + declick.length < r.length /* not the last loop */
@@ -166,9 +213,9 @@ Audio_Region::read ( sample_t *buf, nframes_t pos, nframes_t nframes, int channe

const nframes_t fl = cnt - declick_onset_offset;

declick.apply( buf + ofs + declick_onset_offset,
Fade::Out,
declick_offset, fl );
declick.apply_interleaved( cbuf + ( _clip->channels() * ( ofs + declick_onset_offset ) ),
Fade::Out,
declick_offset, fl, _clip->channels() );
}
if ( lofs < declick.length /* buffer begins within declick length of beginning of loop */
@@ -181,38 +228,59 @@ Audio_Region::read ( sample_t *buf, nframes_t pos, nframes_t nframes, int channe
const nframes_t click_len = lofs + cnt > declick_end ? declick_end - lofs : cnt;

/* this is the beginning of the loop next boundary */
declick.apply( buf + ofs, Fade::In, lofs, click_len );
declick.apply_interleaved( cbuf + ( _clip->channels() * ofs ), Fade::In, lofs, click_len, _clip->channels() );
}
}
else
cnt = _clip->read( buf + ofs, channel, start, len );
cnt = _clip->read( cbuf + ( _clip->channels() * ofs ), -1, start, len );

if ( ! cnt )
return 0;
goto done;

/* apply gain */

buffer_apply_gain_unaligned( buf + ofs, cnt, _scale );
/* just do the whole buffer so we can use the alignment optimized
* version when we're in the middle of a region, this will be full
* anyway */
buffer_apply_gain( cbuf, nframes * _clip->channels(), _scale );

/* perform declicking if necessary */


{
assert( cnt <= nframes );
Fade fade;

fade = declick < _fade_in ? _fade_in : declick;
/* do fade in if necessary */
if ( sofs < fade.length )
fade.apply( buf + ofs, Fade::In, sofs, cnt );
fade.apply_interleaved( cbuf + ( _clip->channels() * ofs ), Fade::In, sofs, cnt, _clip->channels() );

fade = declick < _fade_out ? _fade_out : declick;

/* do fade out if necessary */
if ( start + fade.length > r.offset + r.length )
fade.apply( buf, Fade::Out, ( start + fade.length ) - ( r.offset + r.length ), cnt );
fade.apply_interleaved( cbuf, Fade::Out, ( start + fade.length ) - ( r.offset + r.length ), cnt, _clip->channels() );
}

if ( buf != cbuf )
{
/* now interleave the clip channels into the playback buffer */
for ( int i = 0; i < channels && i < _clip->channels(); i++ )
{
if ( buf_is_empty )
buffer_interleaved_copy( buf, cbuf, i, i, channels, _clip->channels(), nframes );
else
buffer_interleaved_mix( buf, cbuf, i, i, channels, _clip->channels(), nframes );
}
}

done:

if ( buf != cbuf )
{
free( cbuf );
}

return cnt;


+ 10
- 19
timeline/src/Engine/Audio_Sequence.C View File

@@ -40,33 +40,24 @@ Audio_Sequence::play ( sample_t *buf, nframes_t frame, nframes_t nframes, int ch
{
THREAD_ASSERT( Playback );

sample_t *cbuf = new sample_t[ nframes ];

memset( cbuf, 0, nframes * sizeof( sample_t ) );
bool buf_is_empty = true;

/* quick and dirty--let the regions figure out coverage for themselves */
for ( list <Sequence_Widget *>::const_iterator i = _widgets.begin();
i != _widgets.end(); ++i )
{
const Audio_Region *r = (Audio_Region*)(*i);

for ( int i = channels; i--; )
{
int nfr;

if ( ! ( nfr = r->read( cbuf, frame, nframes, i ) ) )
/* error ? */
continue;

if ( channels == 1 )
buffer_mix( buf, cbuf, nframes );
else
buffer_interleave_one_channel_and_mix( buf, cbuf, i, channels, nframes );
}
int nfr;
/* read mixes into buf */
if ( ! ( nfr = r->read( buf, buf_is_empty, frame, nframes, channels ) ) )
/* error ? */
continue;

buf_is_empty = false;
}

delete[] cbuf;

/* FIXME: bogus */
return nframes;
}

+ 1
- 2
timeline/src/Engine/Playback_DS.C View File

@@ -88,7 +88,6 @@ Playback_DS::read_block ( sample_t *buf, nframes_t nframes )
{
if ( sequence() )
{
/* FIXME: how does this work if _delay is not a multiple of bufsize? */
if ( _frame >= _delay )
@@ -121,7 +120,7 @@ Playback_DS::disk_thread ( void )
/* buffer to hold the interleaved data returned by the track reader */
sample_t *buf = buffer_alloc( _nframes * channels() * _disk_io_blocks );
#ifndef AVOID_UNNECESSARY_COPYING
sample_t *cbuf = buffer_alloc( _nframes * _disk_io_blocks );
sample_t *cbuf = buffer_alloc( _nframes * channels() * _disk_io_blocks );
#endif

int blocks_ready = 0;


Loading…
Cancel
Save