new-session-manager/Timeline/Peaks.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.  */
/*******************************************************************************/

#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 <sndfile.h>

#include "Audio_File.H"

#include "assert.h"

#include <math.h>

#include <FL/Fl.H> // for Fl::check();

Peaks::peakbuffer Peaks::_peakbuf;


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 );
}


/* inline void */
/* Peaks::downsample ( Peak *peaks, int s, int e, float *mhi, float *mlo ) const */
/* { */
/*     *mhi = 0; */
/*     *mlo = 0; */

/*     if ( e > _len ) */
/*         e = _len; */

/*     for ( int j = s; j < e; j++ ) */
/*     { */
/*         const float lo = peaks[ j ].min; */
/*         const float hi = peaks[ j ].max; */

/*         if ( hi > *mhi ) */
/*             *mhi = hi; */
/*         if ( lo < *mlo ) */
/*             *mlo = lo; */
/*     } */
/* } */

#if 0
const int HEADER_SIZE = 24;

bool
Peaks::read_header ( void )
{
    int major, minor;

    if ( 2 != fscanf( _fp, "NON-PEAKS%2d%2d", &major, &minor ) )
        return false;

    if ( major != VERSION_MAJOR )
        /* incompatible version */
        return false;

    int data[3];

    int header_size;

    fread( &header_size, sizeof( int ), 1, _fp );

    if ( header_size < sizeof( data ) )
        return false;

    fread( data, sizeof( data ), 1, _fp );

    int chunksize  = data[1];
    int channels   = data[2];
    int peaksize   = data[3];

    _data_offset = header_size + 12;

    if ( header_size > sizeof( data ) )
        fseek( _fp, _data_offset, SEEK_SET );

    return true;
}
#endif

int
Peaks::read_peakfile_peaks ( Peak *peaks, nframes_t s, int npeaks, int chunksize ) const
{
    FILE *fp;

    if ( ! ( fp = fopen( peakname( _clip->name() ), "r" ) ) )
    {
        printf( "failed to open peak file!\n" );
        return 0;
    }

    /* get chunk size of peak file */
    /* FIXME: bogus */
    int pfchunksize = 256;

/*     if ( fread( &pfchunksize, sizeof( int ), 1, fp ) != 1 ) */
/*     { */
/*         printf( "invalid peak file!\n" ); */
/*         return 0; */
/*     } */

    int channels = _clip->channels();
    const int ratio = chunksize / pfchunksize;

    /* locate to start position */
    if ( fseek( fp, (s * channels / pfchunksize) * sizeof( Peak ), SEEK_CUR ) )
        /* failed to seek... peaks not ready? */
        return 0;

    if ( ratio == 1 )
    {
        int len = fread( peaks, sizeof( Peak ) * channels, npeaks, fp );
        fclose( fp );
        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 * channels; 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;

    fclose( fp );

    return i;
}

int
Peaks::read_source_peaks ( Peak *peaks, int npeaks, int 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 ( int 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 < chunksize )
            break;
    }

    delete[] fbuf;

    return i;
}

int
Peaks::read_source_peaks ( Peak *peaks, nframes_t s, int npeaks, int 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, int chunksize ) const
{
    printf( "reading peaks %d @ %d\n", npeaks, chunksize );

    if ( _peakbuf.size < 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 )) );
    }

    assert( s >= 0 );

    _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;
}

/** Return the peak for the range of samples */
/* Peak & */
/* Peaks::peak ( nframes_t start, nframes_t end ) const */
/* { */
/*     /\* Is there a better way to return this?  *\/ */
/*     static Peak p; */

/*     start = (start - _peakbuf.offset) / _peakbuf.buf->chunksize; */
/*     end = (end - _peakbuf.offset) / _peakbuf.buf->chunksize; */

/*     if ( end > _peakbuf.len ) */
/*         end = _peakbuf.len; */

/*     downsample( _peakbuf.buf->data, start, end, &p.max, &p.min ); */

/*     return p; */
/* } */


bool
Peaks::open ( void )
{
    const char *filename = _clip->name();

    int fd;

    if ( ! current() )
        /* Build peaks asyncronously */
        if ( ! fork() )
            exit( make_peaks( 256 ) );

    if ( ( fd = ::open( peakname( filename ), O_RDONLY ) ) < 0 )
        return false;

    {
        struct stat st;

        fstat( fd, &st );

        _len = st.st_size;
    }

    ::close( fd );

    _len = (_len - sizeof( int )) / sizeof( Peak );

    return true;
}

/** 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;
}


/* FIXME: we need to work out a way to run this in another thread and
   possibly stream back the data to the GUI */
/** build peaks file for /filename/ if necessary */
bool
Peaks::make_peaks ( int chunksize )
{
    const char *filename = _clip->name();

    if ( current() )
        return true;

    _clip->seek( 0 );

/*     if ( ! _clip->open() ) */
/*         return false; */

    FILE *fp = fopen( peakname( filename ), "w" );

    if ( fp == NULL )
    {
//        _clip->close();
        return false;
    }

/*     /\* write chunksize first *\/ */
/*     fwrite( &chunksize, sizeof( int ), 1, fp ); */

    Peak peaks[ _clip->channels() ];

    size_t len;
    do {
        len = read_source_peaks( peaks, 1, chunksize );
        fwrite( peaks, sizeof( peaks ), 1, fp );
        /* FIXME: GUI code shouldn't be here! */
//        Fl::check();
    }
    while ( len );

//    _clip->close();

    fclose( fp );

    return true;
}


/** return normalization factor for range of samples from /start/ to
    /end/ (uses known peak data if possible */

/* float */
/* Peaks::normalization_factor( float fpp, nframes_t start, nframes_t end ) const */
/* { */
/*     float s; */

/* //    fill_buffer( fpp, start, end ); */

/* /\*     if ( end - start < _peaks->chunksize * 4 ) *\/ */
/* /\*         fill_buffer( _clip->length() / 4, start, end ); *\/ */
/* /\*     else *\/ */
/* /\*         fill_buffer( _clip->length(), start, end ); *\/ */

/*     Peak p = peak( start, end ); */

/*     s = 1.0f / fabs( p.max ); */

/*     if ( s * p.min < -1.0 ) */
/*         s = 1.0f / fabs( p.min ); */

/*     return s; */
/* } */



Peak_Writer::Peak_Writer ( const char *filename, int 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! */;

//    write_header();
}

Peak_Writer::~Peak_Writer ( )
{
    fclose( _fp );
    delete _peak;
}

void
Peak_Writer::write_header ( void )
{
    fprintf( _fp, "NON-PEAKS%2d%2d", VERSION_MAJOR, VERSION_MINOR );

    int data[] = { _chunksize, _channels, sizeof( Peak ) };

    int size = sizeof( data );

    fwrite( &size, sizeof( size ), 1, _fp );

    fwrite( &data, sizeof( data ), 1, _fp );

}

/** 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;
        }

    }
}