/*******************************************************************************/ /* Copyright (C) 2008 Jonathan Moore Liles */ /* */ /* 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 2 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; see the file COPYING. If not,write to the Free Software */ /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /*******************************************************************************/ /**********/ /* Engine */ /**********/ #include "../Audio_Region.H" #include "Audio_File.H" #include "dsp.h" /** Apply a (portion of) fade from /start/ to /end/ assuming a * buffer size of /nframes/. /start/ and /end/ are relative to the * given buffer, and /start/ may be negative. */ void Audio_Region::Fade::apply ( sample_t *buf, Audio_Region::Fade::fade_dir_e dir, long start, nframes_t end, nframes_t nframes ) const { // printf( "apply fade %s: start=%ld end=%lu\n", dir == Fade::Out ? "out" : "in", start, end ); if ( ! nframes ) return; const nframes_t i = start > 0 ? start : 0; const nframes_t e = end > nframes ? nframes : end; assert( i < nframes ); const float inc = increment(); float fi = ( i - start ) / (float)length; // buf += i; buf = &buf[ i ]; nframes_t n = e - i; assert( i + n <= nframes ); if ( dir == Fade::Out ) { fi = 1.0f - fi; for ( ; n--; fi -= inc ) *(buf++) *= gain( fi ); } else for ( ; n--; fi += inc ) *(buf++) *= gain( fi ); } /* THREAD: IO */ /** read the overlapping part of /channel/ at /pos/ for /nframes/ of this region into /buf/, where /pos/ is in timeline frames */ /* 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 { const Range r = _range; /* do nothing if we aren't covered by this frame range */ if ( pos > r.start + r.length || pos + nframes < r.start ) return 0; /* calculate offsets into file and sample buffer */ nframes_t sofs, ofs, cnt; cnt = nframes; if ( pos < r.start ) { sofs = 0; ofs = r.start - pos; cnt -= ofs; } else { ofs = 0; 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 = min( cnt, nframes - ofs ); if ( len == 0 ) return 0; /* 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 ); if ( _loop ) { nframes_t lofs = sofs % _loop; nframes_t lstart = r.offset + lofs; if ( lofs + len > _loop ) { /* this buffer covers a loop bounary */ /* read the first part */ cnt = _clip->read( buf + ofs, channel, lstart, len - ( ( lofs + len ) - _loop ) ); /* read the second part */ cnt += _clip->read( buf + ofs + cnt, channel, lstart + cnt, len - cnt ); /* TODO: declick/crossfade transition? */ assert( cnt == len ); } else cnt = _clip->read( buf + ofs, channel, lstart, len ); } else cnt = _clip->read( buf + ofs, channel, start, len ); /* apply gain */ buffer_apply_gain( buf + ofs, cnt, _scale ); /* perform declicking if necessary */ /* FIXME: keep the declick defults someplace else */ Fade declick; declick.length = 256; declick.type = Fade::Linear; { Fade fade; fade = declick < _fade_in ? _fade_in : declick; /* do fade in if necessary */ if ( sofs < fade.length ) { const long d = 0 - sofs; assert( cnt <= nframes ); fade.apply( buf + ofs, Fade::In, d, d + fade.length, cnt ); } fade = declick < _fade_out ? _fade_out : declick; /* do fade out if necessary */ // if ( start + cnt + fade.length > r.end ) if ( start + fade.length > ( r.offset + r.length ) ) { const nframes_t d = ( r.offset + r.length ) - start; assert( cnt <= nframes ); fade.apply( buf, Fade::Out, cnt + (long)d - fade.length, cnt + d, cnt ); } } // printf( "read %lu frames\n", cnt ); return cnt; } /** prepare for capturing */ void Audio_Region::prepare ( void ) { log_start(); } /* THREAD: IO */ /** write /nframes/ from /buf/ to source. /buf/ is interleaved and must match the channel layout of the write source! */ nframes_t Audio_Region::write ( nframes_t nframes ) { _range.length += nframes; /* FIXME: too much? */ // _track->damage( FL_DAMAGE_EXPOSE, x() + w(), y(), 10/* FIXME: guess */, h() ); if ( 0 == ( timeline->ts_to_x( _range.length ) % 20 ) ) { nframes_t oldl = _clip->length(); /* get the new size. Remember, this is a read-only handle on the source--not the same one being written to */ _clip->close(); _clip->open(); int W = timeline->ts_to_x( _clip->length() - oldl ); /* why - 1? */ if ( W ) { ++W; Fl::lock(); sequence()->damage( FL_DAMAGE_ALL, x() + w() - W, y(), W, h() ); // Fl::awake(); Fl::unlock(); } } return nframes; } /* THREAD: IO */ /** finalize region capture. Assumes that this *is* a captured region and that no other regions refer to the same source */ bool Audio_Region::finalize ( nframes_t frame ) { DMESSAGE( "finalizing capture region" ); _range.length = frame - _range.start; log_end(); _clip->close(); _clip->open(); /* FIXME: should we attempt to truncate the file? */ Fl::lock(); redraw(); Fl::awake(); Fl::unlock(); return true; }