mirrors
/
non
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
non/Timeline/Peaks.C

814 lines
20 KiB
C
Raw Blame History

/*******************************************************************************/
/* 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.
*/
#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"
#include <errno.h>
#include "Transport.H" // for .recording
#include <list>
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 )
{
static char file[512];
snprintf( file, 512, "%s.peak", filename );
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;
}
struct peakfile_block_header
{
unsigned long chunksize;
unsigned long skip;
};
class Peakfile
{
FILE *_fp;
nframes_t _chunksize;
int _channels; /* number of channels this peakfile represents */
nframes_t _length; /* length, in frames, of the clip this peakfile represents */
const char *_name;
size_t _offset;
struct block_descriptor
{
nframes_t chunksize;
size_t pos;
block_descriptor ( nframes_t chunksize, size_t pos ) : chunksize( chunksize ), pos( pos )
{
}
bool operator< ( const block_descriptor &rhs )
{
return chunksize < rhs.chunksize;
}
};
public:
Peakfile ( )
{
_fp = NULL;
_offset = 0;
_chunksize = 0;
_channels = 0;
_length = 0;
_name =NULL;
}
~Peakfile ( )
{
if ( _fp )
close();
}
/** find the best block for /chunksize/ */
void
find_block ( nframes_t chunksize )
{
rewind( _fp );
clearerr( _fp );
std::list <block_descriptor> blocks;
/* scan all blocks */
do
{
peakfile_block_header bh;
fread( &bh, sizeof( bh ), 1, _fp );
ASSERT( bh.chunksize, "Invalid peak file structure!" );
blocks.push_back( block_descriptor( bh.chunksize, ftell( _fp ) ) );
if ( ! bh.skip )
break;
if ( fseek( _fp, bh.skip, SEEK_CUR ) )
{
WARNING( "seek failed: %s (%lu)", strerror( errno ), bh.skip );
break;
}
}
while ( ! feof( _fp ) );
if ( ! blocks.size() )
FATAL( "invalid peak file?" );
// DMESSAGE( "peakfile has %d blocks.", blocks.size() );
blocks.sort();
/* fall back on the smallest chunksize */
fseek( _fp, blocks.front().pos, SEEK_SET );
_chunksize = blocks.front().chunksize;
/* search for the best-fit chunksize */
for ( std::list <block_descriptor>::const_reverse_iterator i = blocks.rbegin();
i != blocks.rend(); ++i )
if ( chunksize >= i->chunksize )
{
_chunksize = i->chunksize;
fseek( _fp, i->pos, SEEK_SET );
break;
}
_offset = ftell( _fp );
}
/** convert frame number of peak number */
nframes_t frame_to_peak ( nframes_t frame )
{
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 )
{
_chunksize = 0;
_channels = channels;
_name = name;
if ( ! ( _fp = fopen( peakname( name ), "r" ) ) )
return false;
find_block( chunksize );
assert( _chunksize );
return true;
}
bool
open ( FILE *fp, int channels, nframes_t chunksize )
{
_fp = fp;
_chunksize = 0;
_channels = channels;
find_block( chunksize );
assert( _chunksize );
}
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, _offset + 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 );
/* never try to build peaks while recording */
if ( ! ( _peak_writer || transport->recording ) )
{
if ( ! current() )
/* 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 )
{
}
/** returns false if peak file for /filename/ is out of date */
bool
Peaks::current ( void ) const
{
int sfd, pfd;
if ( ( sfd = ::open( _clip->name(), O_RDONLY ) ) < 0 )
return true;
if ( ( pfd = ::open( peakname( _clip->name() ), 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;
}
static void
touch ( int fd )
{
struct stat st;
fstat( fd, &st );
fchmod( fd, st.st_mode );
}
/* The Peak_Builder is for generating peaks from imported or updated sources, or when the
peakfile is simply missing */
class Peak_Builder
{
FILE *fp;
size_t last_block_pos;
const Peaks *_peaks;
void
write_block_header ( nframes_t chunksize )
{
if ( last_block_pos )
{
/* update previous block */
size_t pos = ftell( fp );
fseek( fp, last_block_pos - sizeof( peakfile_block_header ), SEEK_SET );
peakfile_block_header bh;
fread( &bh, sizeof( bh ), 1, fp );
fseek( fp, last_block_pos - sizeof( peakfile_block_header ), SEEK_SET );
// fseek( fp, 0 - sizeof( bh ), SEEK_CUR );
// DMESSAGE( "old block header: chunksize=%lu, skip=%lu", bh.chunksize, bh.skip );
bh.skip = pos - last_block_pos;
// DMESSAGE( "new block header: chunksize=%lu, skip=%lu", bh.chunksize, bh.skip );
fwrite( &bh, sizeof( bh ), 1, fp );
fseek( fp, pos, SEEK_SET );
}
peakfile_block_header bh;
bh.chunksize = chunksize;
bh.skip = 0;
fwrite( &bh, sizeof( bh ), 1, fp );
last_block_pos = ftell( fp );
}
public:
/** generate additional cache levels for a peakfile with only 1 block (ie. that of a new capture) */
bool
make_peaks_mipmap ( void )
{
if ( ! Peaks::mipmapped_peakfiles )
return true;
Audio_File *_clip = _peaks->_clip;
const char *filename = _clip->name();
FILE *rfp;
last_block_pos = sizeof( peakfile_block_header );
/* open for reading */
rfp = fopen( peakname( filename ), "r" );
/* open the file again for appending */
fp = fopen( peakname( filename ), "r+" );
fseek( fp, 0, SEEK_END );
Peak buf[ _clip->channels() ];
/* now build the remaining peak levels, each based on the
* preceding level */
nframes_t cs = Peaks::cache_minimum << Peaks::cache_step;
for ( int i = 1; i < Peaks::cache_levels; ++i, cs <<= Peaks::cache_step )
{
DMESSAGE( "building level %d peak cache", i + 1 );
Peakfile pf;
/* open the peakfile for the previous cache level */
pf.open( rfp, _clip->channels(), cs >> Peaks::cache_step );
write_block_header( cs );
fflush( fp );
size_t len;
nframes_t s = 0;
do {
len = pf.read_peaks( buf, s, 1, cs );
s += cs;
fwrite( buf, sizeof( buf ), len, fp );
}
while ( len );
pf.leave_open();
}
fclose( rfp );
fclose( fp );
return true;
}
bool
make_peaks ( void )
{
Audio_File *_clip = _peaks->_clip;
const char *filename = _clip->name();
DMESSAGE( "building peaks for \"%s\"", filename );
FILE *rfp;
if ( ! ( fp = fopen( peakname( filename ), "w+" ) ) )
return false;
_clip->seek( 0 );
Peak buf[ _clip->channels() ];
DMESSAGE( "building level 1 peak cache" );
write_block_header( Peaks::cache_minimum );
/* build first level from source */
size_t len;
do {
len = _peaks->read_source_peaks( buf, 1, Peaks::cache_minimum );
fwrite( buf, sizeof( buf ), len, fp );
}
while ( len );
/* reopen for reading */
fclose( fp );
make_peaks_mipmap();
DMESSAGE( "done building peaks" );
return true;
}
Peak_Builder ( const Peaks *peaks ) : _peaks( peaks )
{
fp = NULL;
last_block_pos = 0;
}
};
bool
Peaks::make_peaks ( void ) const
{
Peak_Builder pb( this );
return pb.make_peaks();
}
bool
Peaks::make_peaks_mipmap ( void ) const
{
Peak_Builder pb( this );
return pb.make_peaks_mipmap();
}
/** 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::finish_writing ( void )
{
if ( _peak_writer )
{
delete _peak_writer;
_peak_writer = NULL;
}
/* now fill in the rest of the cache */
if ( ! fork() )
exit( make_peaks_mipmap() );
}
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 ), "w" ) ) )
/* error! */;
peakfile_block_header bh;
bh.chunksize = chunksize;
bh.skip = 0;
fwrite( &bh, sizeof( bh ), 1, _fp );
fflush( _fp );
}
Peak_Writer::~Peak_Writer ( )
{
touch( fileno( _fp ) );
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;
}
}
}
Reference in New Issue View Git Blame Copy Permalink