mirrors
/
non
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Clean up Peaks.C

This commit is contained in:
Jonathan Moore Liles 2008-05-11 09:24:38 -05:00
parent d1a2f52352
commit f12363340e
2 changed files with 249 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

438
Timeline/Peaks.C
View File

@ -25,8 +25,6 @@
#include "Peaks.H"
// #include "Timeline.H"
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
@ -40,50 +38,25 @@
#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;
/* whether to cache peaks at multiple resolutions on disk to
* drastically improve performance */
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;
}
Peaks::peakbuffer Peaks::_peakbuf;
static
const char *
@ -96,16 +69,18 @@ peakname ( const char *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
/** update the modification time of file referred to by /fd/ */
static void
touch ( int fd )
{
_fpp = fpp;
struct stat st;
return read_peaks( s, e, (e - s) / fpp, fpp );
fstat( fd, &st );
fchmod( fd, st.st_mode );
}
static int
nearest_power_of_two ( int v )
{
@ -128,6 +103,30 @@ nearest_cached_chunksize ( nframes_t chunksize )
return 0;
}
Peaks::Peaks ( Audio_File *c )
{
_clip = c;
_peak_writer = NULL;
}
Peaks::~Peaks ( )
{
if ( _peak_writer )
delete _peak_writer;
}
/** 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 );
}
struct peakfile_block_header
{
unsigned long chunksize;
@ -230,6 +229,7 @@ public:
break;
}
// DMESSAGE( "using peakfile block for chunksize %lu", _chunksize );
_offset = ftell( _fp );
}
@ -364,11 +364,8 @@ public:
delete[] pbuf;
// close();
return i;
}
};
@ -456,13 +453,10 @@ Peaks::read_source_peaks ( Peak *peaks, int npeaks, nframes_t chunksize ) const
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;
}
@ -481,8 +475,8 @@ Peaks::read_peaks ( nframes_t s, nframes_t e, int npeaks, nframes_t chunksize )
_peakbuf.offset = s;
_peakbuf.buf->chunksize = chunksize;
/* FIXME: compart to (minimum) peakfile chunk size */
if ( chunksize < 256 )
/* FIXME: use actual minimum chunksize from peakfile! */
if ( chunksize < cache_minimum )
_peakbuf.len = read_source_peaks( _peakbuf.buf->data, s, npeaks, chunksize );
else
_peakbuf.len = read_peakfile_peaks( _peakbuf.buf->data, s, npeaks, chunksize );
@ -490,13 +484,6 @@ Peaks::read_peaks ( nframes_t s, nframes_t e, int npeaks, nframes_t 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
@ -521,179 +508,11 @@ Peaks::current ( void ) const
}
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 );
Peaks::Builder pb( this );
return pb.make_peaks();
}
@ -701,7 +520,7 @@ Peaks::make_peaks ( void ) const
bool
Peaks::make_peaks_mipmap ( void ) const
{
Peak_Builder pb( this );
Peaks::Builder pb( this );
return pb.make_peaks_mipmap();
}
@ -721,14 +540,13 @@ Peak::normalization_factor( void ) const
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() );
_peak_writer = new Peaks::Streamer( _clip->name(), cache_minimum, _clip->channels() );
}
void
@ -752,11 +570,17 @@ 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 )
/*
The Streamer is for streaming peaks from audio buffers to disk while
capturing. It works by accumulating a peak value across write()
calls. The Streamer can only generate peaks at a single
chunksize--additional cache levels must be appended after the
Streamer has finished.
*/
Peaks::Streamer::Streamer ( const char *filename, nframes_t chunksize, int channels )
{
_channels = channels;
_chunksize = chunksize;
@ -778,7 +602,7 @@ Peak_Writer::Peak_Writer ( const char *filename, nframes_t chunksize, int channe
fflush( _fp );
}
Peak_Writer::~Peak_Writer ( )
Peaks::Streamer::~Streamer ( )
{
touch( fileno( _fp ) );
@ -789,7 +613,7 @@ Peak_Writer::~Peak_Writer ( )
/** append peaks for samples in /buf/ to peakfile */
void
Peak_Writer::write ( sample_t *buf, nframes_t nframes )
Peaks::Streamer::write ( sample_t *buf, nframes_t nframes )
{
for ( ; nframes--; ++_index, buf += _channels )
{
@ -811,3 +635,157 @@ Peak_Writer::write ( sample_t *buf, nframes_t nframes )
}
}
}
/*
The Builder is for generating peaks from imported or updated
sources, or when the peakfile is simply missing.
*/
void
Peaks::Builder::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 );
}
/** generate additional cache levels for a peakfile with only 1 block (ie. that of a new capture) */
bool
Peaks::Builder::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
Peaks::Builder::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;
}
Peaks::Builder::Builder ( const Peaks *peaks ) : _peaks( peaks )
{
fp = NULL;
last_block_pos = 0;
}

72
Timeline/Peaks.H
View File

@ -30,8 +30,9 @@ struct Peak {
float normalization_factor ( void ) const;
};
#include <stdio.h>
class Audio_File;
class Peak_Writer;
class Peaks
{
@ -57,6 +58,44 @@ class Peaks
}
};
class Streamer
{
FILE *_fp;
Peak *_peak;
int _chunksize;
int _channels;
int _index;
/* not permitted */
Streamer ( const Streamer &rhs );
const Streamer &operator= ( const Streamer &rhs );
public:
Streamer ( const char *filename, nframes_t chunksize, int channels );
~Streamer ( );
void write ( sample_t *buf, nframes_t nframes );
};
class Builder
{
FILE *fp;
size_t last_block_pos;
const Peaks *_peaks;
void write_block_header ( nframes_t chunksize );
public:
bool make_peaks_mipmap ( void );
bool make_peaks ( void );
Builder ( const Peaks *peaks );
};
static peakbuffer _peakbuf;
Audio_File *_clip;
@ -68,16 +107,12 @@ class Peaks
int read_source_peaks ( Peak *peaks, int npeaks, nframes_t chunksize ) const;
int read_peakfile_peaks ( Peak *peaks, nframes_t s, int npeaks, nframes_t chunksize ) const;
Peak_Writer * volatile _peak_writer; /* exists when streaming peaks to disk */
size_t last_block_pos; /* FIXME: only needed in make_peaks! */
Streamer * volatile _peak_writer; /* exists when streaming peaks to disk */
/* not permitted */
Peaks ( const Peaks &rhs );
const Peaks &operator= ( const Peaks &rhs );
friend class Peak_Builder;
public:
static bool mipmapped_peakfiles;
@ -97,7 +132,6 @@ public:
int fill_buffer ( float fpp, nframes_t s, nframes_t e ) const;
void read ( int X, float *hi, float *lo ) const;
bool open ( void );
bool current ( void ) const;
bool make_peaks ( void ) const;
@ -107,27 +141,3 @@ public:
void finish_writing ( void );
void write ( sample_t *buf, nframes_t nframes );
};
#include <stdio.h>
class Peak_Writer
{
FILE *_fp;
Peak *_peak;
int _chunksize;
int _channels;
int _index;
/* not permitted */
Peak_Writer ( const Peak_Writer &rhs );
const Peak_Writer &operator= ( const Peak_Writer &rhs );
public:
Peak_Writer ( const char *filename, nframes_t chunksize, int channels );
~Peak_Writer ( );
void write ( sample_t *buf, nframes_t nframes );
};