621 lines
16 KiB
C
621 lines
16 KiB
C
|
|
/*******************************************************************************/
|
|
/* 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. */
|
|
/*******************************************************************************/
|
|
|
|
|
|
/*
|
|
peakfile reading/writing.
|
|
|
|
Here's how it works:
|
|
|
|
Peakfiles are of the form 'name-[chunksize].peak', and contain
|
|
floating point min/max pairs for an entire soundfile at a certain
|
|
chunksize.
|
|
|
|
It gets a little complicated because peakfiles are generated
|
|
asynchronously and streamed to disk when capturing.
|
|
|
|
When the GUI requests the peaks for a range of samples at a certain
|
|
chunksize, a search is performed for a peakfile--starting with the
|
|
requested chunksize, and then moving to smaller chunksizes--that
|
|
exists and contains the peaks for the requested range (which it may
|
|
not--if the peaks are in the process of being written). The peaks,
|
|
if available, are then read from disk, downsampled to the exact
|
|
chunksize requested, and displayed.
|
|
|
|
On the generation end, peaks are either streamed to disk while
|
|
recording (and therefore more or less in real time), or a process
|
|
is forked to generate the entire peak file (either directly from
|
|
the source, or from a higher-resolution peak file that exists and
|
|
is complete).
|
|
|
|
The end result is that peaks are:
|
|
|
|
* read synchronously
|
|
* generated asynchronously
|
|
* cached at many resolutions
|
|
|
|
*/
|
|
|
|
|
|
#include "Peaks.H"
|
|
|
|
// #include "Timeline.H"
|
|
|
|
#include <sys/mman.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "Audio_File.H"
|
|
|
|
#include "assert.h"
|
|
|
|
#include <math.h>
|
|
|
|
#include <FL/Fl.H> // for Fl::check();
|
|
|
|
#include "debug.h"
|
|
|
|
Peaks::peakbuffer Peaks::_peakbuf;
|
|
|
|
|
|
bool Peaks::mipmapped_peakfiles = true;
|
|
|
|
/* chunksizes at which to generate peakfiles (on demand). This should
|
|
pretty much cover the usable range. Better performance can be
|
|
achieved at high zoom-levels and for compressed sources with a
|
|
minimum of 64, but those files are up into the megabytes. */
|
|
const int Peaks::cache_minimum = 256; /* minimum chunksize to build peakfiles for */
|
|
const int Peaks::cache_levels = 8; /* number of sampling levels in peak cache */
|
|
// const int Peaks::cache_step = 2; /* powers of two between each level. 4 == 256, 2048, 16384, ... */
|
|
|
|
const int Peaks::cache_step = 1; /* powers of two between each level. 4 == 256, 2048, 16384, ... */
|
|
|
|
/* Peaks ( ) */
|
|
/* { */
|
|
/* _clip = NULL; */
|
|
/* } */
|
|
|
|
Peaks::Peaks ( Audio_File *c )
|
|
{
|
|
_clip = c;
|
|
_peak_writer = NULL;
|
|
}
|
|
|
|
Peaks::~Peaks ( )
|
|
{
|
|
if ( _peak_writer )
|
|
delete _peak_writer;
|
|
}
|
|
|
|
|
|
static
|
|
const char *
|
|
peakname ( const char *filename, nframes_t chunksize )
|
|
{
|
|
static char file[512];
|
|
|
|
snprintf( file, 512, "%s-[%d].peak", filename, chunksize );
|
|
|
|
return (const char*)&file;
|
|
}
|
|
|
|
/** Prepare a buffer of peaks from /s/ to /e/ for reading. Must be
|
|
* called before any calls to operator[] */
|
|
int
|
|
Peaks::fill_buffer ( float fpp, nframes_t s, nframes_t e ) const
|
|
{
|
|
_fpp = fpp;
|
|
|
|
return read_peaks( s, e, (e - s) / fpp, fpp );
|
|
}
|
|
|
|
static int
|
|
nearest_power_of_two ( int v )
|
|
{
|
|
int p = 1;
|
|
while ( 1 << p < v )
|
|
++p;
|
|
|
|
return 1 << p;
|
|
}
|
|
|
|
static nframes_t
|
|
nearest_cached_chunksize ( nframes_t chunksize )
|
|
{
|
|
nframes_t r = nearest_power_of_two( chunksize );
|
|
|
|
for ( int i = Peaks::cache_levels; i--; r >>= Peaks::cache_step )
|
|
if ( chunksize >= r )
|
|
return r;
|
|
|
|
return 0;
|
|
}
|
|
|
|
class Peakfile
|
|
{
|
|
|
|
FILE *_fp;
|
|
nframes_t _chunksize;
|
|
int _channels;
|
|
const char *_name;
|
|
|
|
public:
|
|
|
|
Peakfile ( )
|
|
{
|
|
_fp = NULL;
|
|
_chunksize = 0;
|
|
_channels = 0;
|
|
_name =NULL;
|
|
}
|
|
|
|
~Peakfile ( )
|
|
{
|
|
if ( _fp )
|
|
close();
|
|
}
|
|
|
|
/** convert frame number of peak number */
|
|
nframes_t frame_to_peak ( nframes_t frame )
|
|
{
|
|
/* how many powers of two is chunksize > cache_minimum?
|
|
skip clip size of peaks at increasing powers of two until
|
|
we reach the closest one less than chunksize. Then
|
|
address normally.*/
|
|
|
|
return frame * _channels / _chunksize;
|
|
}
|
|
|
|
/** return the number of peaks in already open peakfile /fp/ */
|
|
nframes_t
|
|
npeaks ( void ) const
|
|
{
|
|
struct stat st;
|
|
|
|
fstat( fileno( _fp ), &st );
|
|
|
|
return st.st_size / sizeof( Peak );
|
|
}
|
|
|
|
/** returns true if the peakfile contains /npeaks/ peaks starting at sample /s/ */
|
|
bool
|
|
contains ( nframes_t start, nframes_t npeaks )
|
|
{
|
|
return frame_to_peak( start ) + npeaks <= this->npeaks();
|
|
}
|
|
|
|
/** given soundfile name /name/, try to open the best peakfile for /chunksize/ */
|
|
bool
|
|
open ( const char *name, nframes_t chunksize, int channels )
|
|
{
|
|
_channels = channels;
|
|
_name = name;
|
|
|
|
for ( _chunksize = nearest_cached_chunksize( chunksize );
|
|
_chunksize >= Peaks::cache_minimum; _chunksize >>= Peaks::cache_step )
|
|
if ( ( _fp = fopen( peakname( name, _chunksize ), "r" ) ) )
|
|
break;
|
|
|
|
return _fp != NULL;
|
|
}
|
|
|
|
bool
|
|
open ( FILE *fp, int channels, nframes_t chunksize )
|
|
{
|
|
_fp = fp;
|
|
_chunksize = chunksize;
|
|
_channels = channels;
|
|
}
|
|
|
|
void
|
|
leave_open ( void )
|
|
{
|
|
_fp = NULL;
|
|
}
|
|
|
|
void
|
|
close ( void )
|
|
{
|
|
fclose( _fp );
|
|
_fp = NULL;
|
|
}
|
|
|
|
/** read /npeaks/ peaks at /chunksize/ starting at sample /s/
|
|
* assuming the peakfile contains data for /channels/
|
|
* channels. Place the result in buffer /peaks/, which must be
|
|
* large enough to fit the entire request. Returns the number of
|
|
* peaks actually read, which may be fewer than were requested. */
|
|
int
|
|
read_peaks ( Peak *peaks, nframes_t s, int npeaks, nframes_t chunksize )
|
|
{
|
|
if ( ! _fp )
|
|
return 0;
|
|
|
|
const unsigned int ratio = chunksize / _chunksize;
|
|
|
|
/* locate to start position */
|
|
if ( fseek( _fp, frame_to_peak( s ) * sizeof( Peak ), SEEK_SET ) )
|
|
/* failed to seek... peaks not ready? */
|
|
return 0;
|
|
|
|
if ( ratio == 1 )
|
|
{
|
|
int len = fread( peaks, sizeof( Peak ) * _channels, npeaks, _fp );
|
|
// close;
|
|
return len;
|
|
}
|
|
|
|
Peak *pbuf = new Peak[ ratio * _channels ];
|
|
|
|
size_t len = 0;
|
|
|
|
int i;
|
|
for ( i = 0; i < npeaks; ++i )
|
|
{
|
|
/* read in a buffer */
|
|
len = fread( pbuf, sizeof( Peak ) * _channels, ratio, _fp );
|
|
|
|
Peak *pk = peaks + (i * _channels);
|
|
|
|
/* get the peak for each channel */
|
|
for ( int j = 0; j < _channels; ++j )
|
|
{
|
|
Peak *p = &pk[ j ];
|
|
|
|
p->min = 0;
|
|
p->max = 0;
|
|
|
|
const Peak *pb = pbuf + j;
|
|
|
|
for ( int k = len; k--; pb += _channels )
|
|
{
|
|
if ( pb->max > p->max )
|
|
p->max = pb->max;
|
|
if ( pb->min < p->min )
|
|
p->min = pb->min;
|
|
}
|
|
|
|
}
|
|
|
|
if ( len < ratio )
|
|
break;
|
|
}
|
|
|
|
delete[] pbuf;
|
|
|
|
// close();
|
|
|
|
return i;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
int
|
|
Peaks::read_peakfile_peaks ( Peak *peaks, nframes_t s, int npeaks, nframes_t chunksize ) const
|
|
{
|
|
|
|
nframes_t ncc = nearest_cached_chunksize( chunksize );
|
|
|
|
if ( ! _peak_writer && ! current( cache_minimum ) )
|
|
/* Build peaks asyncronously */
|
|
if ( ! fork() )
|
|
exit( make_peaks( ) );
|
|
else
|
|
return 0;
|
|
|
|
Peakfile _peakfile;
|
|
|
|
if ( ! _peakfile.open( _clip->name(), chunksize, _clip->channels() ) )
|
|
return 0;
|
|
else if ( ! _peakfile.contains( s, npeaks ) )
|
|
{
|
|
/* the best peakfile for this chunksize doesn't have the
|
|
* peaks we need. Perhaps it's still being constructed,
|
|
* try the next best, then give up. */
|
|
if ( ! _peakfile.open( _clip->name(), chunksize >> 1, _clip->channels() ) )
|
|
return 0;
|
|
}
|
|
|
|
return _peakfile.read_peaks( peaks, s, npeaks, chunksize );
|
|
|
|
// _peakfile.close();
|
|
|
|
}
|
|
|
|
|
|
int
|
|
Peaks::read_source_peaks ( Peak *peaks, int npeaks, nframes_t chunksize ) const
|
|
{
|
|
int channels = _clip->channels();
|
|
|
|
sample_t *fbuf = new sample_t[ chunksize * channels ];
|
|
|
|
size_t len;
|
|
|
|
int i;
|
|
for ( i = 0; i < npeaks; ++i )
|
|
{
|
|
/* read in a buffer */
|
|
len = _clip->read( fbuf, -1, chunksize );
|
|
|
|
Peak *pk = peaks + (i * channels);
|
|
|
|
/* get the peak for each channel */
|
|
for ( int j = 0; j < channels; ++j )
|
|
{
|
|
Peak &p = pk[ j ];
|
|
|
|
p.min = 0;
|
|
p.max = 0;
|
|
|
|
for ( nframes_t k = j; k < len * channels; k += channels )
|
|
{
|
|
if ( fbuf[ k ] > p.max )
|
|
p.max = fbuf[ k ];
|
|
if ( fbuf[ k ] < p.min )
|
|
p.min = fbuf[ k ];
|
|
}
|
|
|
|
}
|
|
|
|
if ( len < (nframes_t)chunksize )
|
|
break;
|
|
}
|
|
|
|
delete[] fbuf;
|
|
|
|
return i;
|
|
}
|
|
|
|
int
|
|
Peaks::read_source_peaks ( Peak *peaks, nframes_t s, int npeaks, nframes_t chunksize ) const
|
|
{
|
|
// _clip->open();
|
|
_clip->seek( s );
|
|
|
|
int i = read_source_peaks( peaks, npeaks, chunksize );
|
|
|
|
// _clip->close();
|
|
|
|
return i;
|
|
}
|
|
|
|
int
|
|
Peaks::read_peaks ( nframes_t s, nframes_t e, int npeaks, nframes_t chunksize ) const
|
|
{
|
|
// printf( "reading peaks %d @ %d\n", npeaks, chunksize );
|
|
|
|
if ( _peakbuf.size < (nframes_t)( npeaks * _clip->channels() ) )
|
|
{
|
|
_peakbuf.size = npeaks * _clip->channels();
|
|
// printf( "reallocating peak buffer %li\n", _peakbuf.size );
|
|
_peakbuf.buf = (peakdata*)realloc( _peakbuf.buf, sizeof( peakdata ) + (_peakbuf.size * sizeof( Peak )) );
|
|
}
|
|
|
|
_peakbuf.offset = s;
|
|
_peakbuf.buf->chunksize = chunksize;
|
|
|
|
/* FIXME: compart to (minimum) peakfile chunk size */
|
|
if ( chunksize < 256 )
|
|
_peakbuf.len = read_source_peaks( _peakbuf.buf->data, s, npeaks, chunksize );
|
|
else
|
|
_peakbuf.len = read_peakfile_peaks( _peakbuf.buf->data, s, npeaks, chunksize );
|
|
|
|
return _peakbuf.len;
|
|
}
|
|
|
|
/* FIXME: what purpose does this serve now? */
|
|
bool
|
|
Peaks::open ( void )
|
|
{
|
|
|
|
/* const char *filename = _clip->name(); */
|
|
|
|
/* /\* FIXME: determine this based on zoom level *\/ */
|
|
/* const nframes_t chunksize = 256; */
|
|
|
|
/* /\* if ( ! current( chunksize ) ) *\/ */
|
|
/* /\* /\\* Build peaks asyncronously *\\/ *\/ */
|
|
/* /\* if ( ! fork() ) *\/ */
|
|
/* /\* exit( make_peaks( chunksize ) ); *\/ */
|
|
|
|
/* return true; */
|
|
|
|
}
|
|
|
|
|
|
/** returns false if peak file for /filename/ is out of date */
|
|
bool
|
|
Peaks::current ( nframes_t chunksize ) const
|
|
{
|
|
int sfd, pfd;
|
|
|
|
if ( ( sfd = ::open( _clip->name(), O_RDONLY ) ) < 0 )
|
|
return true;
|
|
|
|
if ( ( pfd = ::open( peakname( _clip->name(), chunksize ), O_RDONLY ) ) < 0 )
|
|
return false;
|
|
|
|
struct stat sst, pst;
|
|
|
|
fstat( sfd, &sst );
|
|
fstat( pfd, &pst );
|
|
|
|
close( sfd );
|
|
close( pfd );
|
|
|
|
return sst.st_mtime <= pst.st_mtime;
|
|
}
|
|
|
|
|
|
/** build peaks file at /chunksize/. If higher-resolution peaks
|
|
already exist, downsample those rather than building from
|
|
scratch */
|
|
bool
|
|
Peaks::make_peaks ( void ) const
|
|
{
|
|
const char *filename = _clip->name();
|
|
|
|
_clip->seek( 0 );
|
|
|
|
FILE *fp[ cache_levels ];
|
|
|
|
Peak buf[ _clip->channels() ];
|
|
|
|
if ( ! ( fp[ 0 ] = fopen( peakname( filename, cache_minimum ), "w+" ) ) )
|
|
return false;
|
|
|
|
DMESSAGE( "building level 1 peak cache" );
|
|
|
|
/* build first level from source */
|
|
size_t len;
|
|
do {
|
|
len = read_source_peaks( buf, 1, cache_minimum );
|
|
|
|
fwrite( buf, sizeof( buf ), len, fp[ 0 ] );
|
|
}
|
|
while ( len );
|
|
|
|
/* now build the remaining peak levels, each based on the
|
|
* preceding level */
|
|
|
|
nframes_t cs = cache_minimum << cache_step;
|
|
for ( int i = 1; i < cache_levels; ++i, cs <<= cache_step )
|
|
{
|
|
DMESSAGE( "building level %d peak cache", i + 1 );
|
|
|
|
Peakfile pf;
|
|
|
|
if ( ! ( fp[ i ] = fopen( peakname( filename, cs ), "w+" ) ) )
|
|
{
|
|
DWARNING( "could not open peakfile for writing" );
|
|
return false;
|
|
}
|
|
|
|
/* open the peakfile for the previous cache level */
|
|
pf.open( fp[ i - 1 ], _clip->channels(), cs >> cache_step );
|
|
|
|
size_t len;
|
|
nframes_t s = 0;
|
|
do {
|
|
len = pf.read_peaks( buf, s, 1, cs );
|
|
s += cs;
|
|
|
|
fwrite( buf, sizeof( buf ), len, fp[ i ] );
|
|
}
|
|
while ( len );
|
|
|
|
pf.leave_open();
|
|
}
|
|
|
|
/* all done */
|
|
for ( int i = cache_levels; i--; )
|
|
fclose( fp[ i ] );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/** return normalization factor for a single peak, assuming the peak
|
|
* represents a downsampling of the entire range to be normalized. */
|
|
float
|
|
Peak::normalization_factor( void ) const
|
|
{
|
|
float s;
|
|
|
|
s = 1.0f / fabs( this->max );
|
|
|
|
if ( s * this->min < -1.0 )
|
|
s = 1.0f / fabs( this->min );
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
/* wrapper for peak writer */
|
|
void
|
|
Peaks::prepare_for_writing ( void )
|
|
{
|
|
assert( ! _peak_writer );
|
|
|
|
_peak_writer = new Peak_Writer( _clip->name(), cache_minimum, _clip->channels() );
|
|
}
|
|
|
|
void
|
|
Peaks::write ( sample_t *buf, nframes_t nframes )
|
|
{
|
|
_peak_writer->write( buf, nframes );
|
|
}
|
|
|
|
/* The Peak_Writer is for streaming peaks from audio buffers to disk
|
|
* while capturing. It works by accumulating a peak value across
|
|
* write() calls. */
|
|
|
|
Peak_Writer::Peak_Writer ( const char *filename, nframes_t chunksize, int channels )
|
|
{
|
|
|
|
_channels = channels;
|
|
_chunksize = chunksize;
|
|
_index = 0;
|
|
|
|
_peak = new Peak[ channels ];
|
|
memset( _peak, 0, sizeof( Peak ) * channels );
|
|
|
|
if ( ! ( _fp = fopen( peakname( filename, chunksize ), "w" ) ) )
|
|
/* error! */;
|
|
}
|
|
|
|
Peak_Writer::~Peak_Writer ( )
|
|
{
|
|
fclose( _fp );
|
|
delete[] _peak;
|
|
}
|
|
|
|
/** append peaks for samples in /buf/ to peakfile */
|
|
void
|
|
Peak_Writer::write ( sample_t *buf, nframes_t nframes )
|
|
{
|
|
for ( ; nframes--; ++_index, buf += _channels )
|
|
{
|
|
for ( int j = 0; j < _channels; ++j )
|
|
{
|
|
Peak *p = _peak + j;
|
|
|
|
if ( *buf > p->max )
|
|
p->max = *buf;
|
|
if ( *buf < p->min )
|
|
p->min = *buf;
|
|
}
|
|
|
|
if ( _index == _chunksize - 1 )
|
|
{
|
|
fwrite( _peak, sizeof( Peak ), _channels, _fp );
|
|
memset( _peak, 0, sizeof( Peak ) * _channels );
|
|
_index = 0;
|
|
}
|
|
|
|
}
|
|
}
|