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

Work on supporting actual audio backing. WIP.

pull/3/head
Jonathan Moore Liles 2008-02-16 17:12:23 -06:00
parent 1750df5f5e
commit 41b62781d1
10 changed files with 308 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
Clip.H Normal file
View File

@ -0,0 +1,50 @@
/*******************************************************************************/
/* 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. */
/*******************************************************************************/
#pragma once
typedef unsigned long nframes_t;
#include "Peaks.H"
class Clip
{
char *_filename;
Peaks _peaks;
nframes_t _length; /* length of clip in samples */
public:
Clip ( const char *filename )
{
_filename = NULL;
// FIXME: open file
_peaks.open( filename );
}
Peaks const * peaks ( void ) { return &_peaks; }
const char *name ( void ) { return _filename; }
nframes_t length ( void ) { return _length; }
};

6
Makefile
View File

@ -4,7 +4,7 @@ CXXFLAGS=-ggdb
LIBS=`fltk-config --ldflags`
# CXXFLAGS=`fltk-config -cxxflags`
OBJS=Waveform.o Region.o main.o
OBJS=Waveform.o Region.o main.o Peaks.o
.C.o:
$(CXX) $(CXXFLAGS) -c $< -o $@
@ -14,3 +14,7 @@ test: $(OBJS)
clean:
rm -f $(OBJS) test
valgrind:
valgrind ./test

106
Peaks.C Normal file
View File

@ -0,0 +1,106 @@
/*******************************************************************************/
/* 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 <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void
Peaks::downsample ( int s, int e, float *mhi, float *mlo ) const
{
*mhi = -1.0;
*mlo = 1.0;
if ( e > _len )
e = _len;
for ( int j = s; j < e; j++ )
{
const float lo = _peaks->data[ j ].min;
const float hi = _peaks->data[ j ].max;
if ( hi > *mhi )
*mhi = hi;
if ( lo < *mlo )
*mlo = lo;
}
}
void
Peaks::read ( int X, float *hi, float *lo ) const
{
int start = X * timeline.fpp;
int end = (X + 1) * timeline.fpp;
downsample( start, end, hi, lo );
}
/* virtual array. Index is a Pixel value, and it returns the
* (resampled) peaks for that pixel based on the current timeline
* zoom. */
Peak &
Peaks::operator[] ( int X ) const
{
/* Is there a better way to return this? */
static Peak p;
int start = X * timeline.fpp;
int end = (X + 1) * timeline.fpp;
downsample( start, end, &p.max, &p.min );
return p;
}
bool
Peaks::open ( const char *filename )
{
char file[512];
snprintf( file, 512, "%s.peak", filename );
int fd;
if ( ( fd = ::open( file, O_RDONLY ) ) < 0 )
{
/* generate peaks here */
}
{
struct stat st;
fstat( fd, &st );
_len = st.st_size;
}
_peaks = (peaks*)mmap( NULL, _len, PROT_READ, MAP_SHARED, fd, 0 );
if ( _peaks == MAP_FAILED )
printf( "failed to create mapping! " );
_len = (_len - sizeof( int )) / sizeof( Peak );
}

57
Peaks.H Normal file
View File

@ -0,0 +1,57 @@
/*******************************************************************************/
/* 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 <stdlib.h>
struct Peak {
float min;
float max;
};
class Peaks
{
struct peaks {
int chunksize; /* should always be a power of 2 */
Peak data[];
};
peaks *_peaks;
size_t _len;
public:
Peaks ( void )
{
_peaks = new peaks;
_peaks->chunksize = 0;
// _peaks->data = NULL;
_len = 0;
}
void downsample ( int s, int e, float *mhi, float *mlo ) const;
void read ( int X, float *hi, float *lo ) const;
bool open ( const char *filename );
Peak & operator[] ( int X ) const;
};

17
Region.C
View File

@ -31,6 +31,12 @@
extern Timeline timeline;
Region::Region ( int X, int Y, int W, int H, const char *L ) : Waveform( X, Y, W, H, L )
{
init();
}
void
Region::init ( void )
{
align( FL_ALIGN_INSIDE | FL_ALIGN_LEFT | FL_ALIGN_BOTTOM | FL_ALIGN_CLIP );
labeltype( FL_SHADOW_LABEL );
@ -52,6 +58,11 @@ Region::Region ( const Region & rhs ) : Waveform( rhs )
_track = rhs._track;
}
Region::Region ( Clip *c ) : Waveform( c )
{
init();
}
void
Region::trim ( enum trim_e t, int X )
{
@ -219,10 +230,10 @@ Region::draw ( void )
draw_label();
static char pat[200];
/* static char pat[200]; */
sprintf( pat, "start %lu, end %lu", _start, _end );
/* sprintf( pat, "start %lu, end %lu", _start, _end ); */
fl_draw( pat, x(), y() + h() / 2 );
/* fl_draw( pat, x(), y() + h() / 2 ); */
}

3
Region.H
View File

@ -32,11 +32,14 @@ class Region : public Waveform
void trim ( enum trim_e t, int X );
void init ( void );
public:
Region ( int X, int Y, int W, int H, const char *L=0 );
Region ( const Region & rhs );
Region ( Clip *c );
int handle ( int m );
void draw ( void );

2
Timeline.H
View File

@ -26,3 +26,5 @@ struct Timeline {
float fpp; /* frames per pixel */
};
extern Timeline timeline;

92
Waveform.C
View File

@ -23,16 +23,21 @@
#include <FL/Fl.H>
#include "Waveform.H"
#include "Clip.H"
// extern Timeline timeline;
// #include "Timeline.H"
#include <math.h>
extern Fl_Color velocity_colors[];
Waveform::Waveform ( int X, int Y, int W, int H, const char *L ) : Fl_Widget( X, Y, W, H, L )
{
_scale = 1;
_clip = NULL;
_start = _end = 0;
}
int measure = 50;
@ -55,6 +60,12 @@ Waveform::draw ( void )
draw( X, y(), W, h() );
}
void
Waveform::read_peaks ( tick_t X, float *hi, float *lo )
{
_clip->peaks()->read( X, hi, lo );
}
void
Waveform::draw ( int X, int Y, int W, int H )
{
@ -69,50 +80,53 @@ Waveform::draw ( int X, int Y, int W, int H )
j = 0;
for ( int x = X; x < X + W; ++x )
{
float lo = _peaks[ start + j++ ];
float hi = _peaks[ start + j++ ];
// read_peaks( x, &hi, &lo );
Peak p = (*_clip->peaks())[ x ];
int mid = Y + (H / 2);
// FIXME: cache this stuff.
// fl_color( fl_color_average( selection_color(), fl_contrast( fl_darker( FL_BLUE ), selection_color() ), fabs( hi - lo ) ) );
fl_color( fl_color_average( FL_RED, selection_color(), fabs( hi - lo ) ) );
fl_color( fl_color_average( FL_RED, selection_color(), fabs( p.max - p.min ) ) );
p.max *= _scale;
p.min *= _scale;
hi *= _scale;
lo *= _scale;
if ( lo < -1.0 || hi > 1.0 )
if ( p.min < -1.0 || p.max > 1.0 )
fl_color( FL_RED );
fl_line( x, mid + (H / 2 * lo), x, mid + (H / 2 * hi) );
fl_line( x, mid + (H / 2 * p.min), x, mid + (H / 2 * p.max) );
}
fl_color( fl_darker( fl_darker( selection_color() ) ) );
fl_line_style( FL_SOLID, 2 );
fl_begin_line();
j = 0;
for ( int x = X; x < X + W; ++x )
{
float v = _peaks[ start + j ] * _scale;
j += 2;
fl_vertex( x, Y + (H / 2) + ((float)H / 2 * v ));
Peak p = (*_clip->peaks())[ x ];
p.min *= _scale;
fl_vertex( x, Y + (H / 2) + ((float)H / 2 * p.min ));
}
fl_end_line();
fl_begin_line();
j = 1;
for ( int x = X; x < X + W; ++x )
{
float v = _peaks[ start + j ] * _scale;
j += 2;
fl_vertex( x, Y + (H / 2) + ((float)H / 2 * v ));
Peak p = (*_clip->peaks())[ x ];
p.max *= _scale;
fl_vertex( x, Y + (H / 2) + ((float)H / 2 * p.max ));
}
fl_end_line();
@ -125,53 +139,12 @@ Waveform::draw ( int X, int Y, int W, int H )
}
void
Waveform::downsample ( int s, int e, float *mhi, float *mlo )
{
*mhi = -1.0;
*mlo = 1.0;
int start = s * 2;
int end = e * 2;
for ( int j = start; j < end; )
{
float lo = _peaks[ j++ ];
float hi = _peaks[ j++ ];
if ( hi > *mhi )
*mhi = hi;
if ( lo < *mlo )
*mlo = lo;
}
}
void
Waveform::normalize ( void )
{
/* float mhi = -1.0; */
/* float mlo = 1.0; */
float mhi, mlo;
downsample( _start, _end, &mhi, &mlo );
/* int start = _start * 2; */
/* int end = _end * 2; */
/* for ( int j = start; j < end; ) */
/* { */
/* float lo = _peaks[ j++ ]; */
/* float hi = _peaks[ j++ ]; */
/* if ( hi > mhi ) */
/* mhi = hi; */
/* if ( lo < mlo ) */
/* mlo = lo; */
/* } */
_clip->peaks()->downsample( _start, _end, &mhi, &mlo );
_scale = 1.0f / (float)mhi;
@ -180,6 +153,5 @@ Waveform::normalize ( void )
_scale = fabs( _scale );
// printf( "scale = %f, hi=%f, lo=%f\n", _scale, mhi, mlo );
redraw();
}

21
Waveform.H
View File

@ -26,12 +26,16 @@
typedef unsigned long tick_t;
#include "Clip.H"
class Waveform : public Fl_Widget
{
protected:
float *_peaks;
Clip *_clip; /* clip this waveform represents */
// float *_peaks;
tick_t _start;
tick_t _end;
@ -43,9 +47,18 @@ public:
Waveform ( int X, int Y, int W, int H, const char *L=0 );
Waveform ( Clip *c ) : Fl_Widget( 0, 0, 500, 100, "" )
{
_clip = c;
label( _clip->name() );
_end = _clip->length();
}
Waveform ( const Waveform & rhs ) : Fl_Widget( rhs.x(), rhs.y(), rhs.w(), rhs.h(), rhs.label() )
{
_peaks = rhs._peaks;
_clip = rhs._clip;
_start = rhs._start;
_end = rhs._end;
@ -58,9 +71,9 @@ public:
void start ( tick_t s ) { _start = s; }
void end ( tick_t e ) { _end = e; }
void peaks ( float *p ) { _peaks = p; }
// void peaks ( float *p ) { _peaks = p; }
void normalize ( void );
void downsample ( int s, int e, float *mhi, float *mlo );
void read_peaks ( tick_t X, float *hi, float *lo );
};

44
main.C
View File

@ -24,6 +24,7 @@
#include <FL/Fl_Scroll.H>
#include <FL/Fl_Pack.H>
#include <FL/Fl_Group.H>
#include <FL/Fl_Slider.H>
#include "Waveform.H"
#include "Region.H"
@ -48,6 +49,13 @@ init_colors ( void )
Timeline timeline;
void
cb_zoom ( Fl_Widget *w, void *v )
{
timeline.fpp = ((Fl_Slider*)w)->value();
timeline.scroll->redraw();
}
int
main ( int argc, char **argv )
{
@ -56,8 +64,8 @@ main ( int argc, char **argv )
Fl_Double_Window *main_window = new Fl_Double_Window( 0, 0, 800, 600 );
timeline.scroll = new Fl_Scroll( 0, 0, 800, 600 );
timeline.fpp = 100;
timeline.scroll = new Fl_Scroll( 0, 24, 800, 600 - 24 );
timeline.fpp = 1;
Fl_Pack *tracks = new Fl_Pack( 0, 0, 5000, 5000 );
tracks->type( Fl_Pack::VERTICAL );
@ -72,30 +80,16 @@ main ( int argc, char **argv )
// pack->type( Fl_Pack::VERTICAL );
// pack->box( FL_DOWN_BOX );
Region *wave = new Region( 0, 0, 5000, 100, "foo" );
// Region *wave = new Region( 0, 0, 5000, 100, "foo" );
FILE *fp;
Region *wave = new Region( new Clip( "foo.wav" ) );
fp = fopen( "peaks", "r" );
wave->resize( 0, 0, 500, 100 );
struct stat st;
fstat( fileno( fp ), &st );
size_t len = st.st_size;
/* float chunk_size; */
/* fread( &chunk_size, sizeof( chunk_size ), 1, fp ); */
/* printf( "%f\n", chunk_size ); */
float *peaks = new float[ len / sizeof( float ) ];
fread( peaks, len, 1, fp );
wave->peaks( peaks );
// wave->peaks( peaks );
wave->start( 0 );
wave->end( (len / sizeof( float )) / 2 );
// wave->end( (len / sizeof( float )) / 2 );
wave->end( 50 );
wave->color( FL_CYAN );
wave->selection_color( fl_darker( FL_GRAY ) );
@ -125,6 +119,12 @@ main ( int argc, char **argv )
tracks->end();
timeline.scroll->end();
Fl_Slider *zoom_slider = new Fl_Slider( 0, 0, 800, 24 );
zoom_slider->type( 1 );
zoom_slider->callback( cb_zoom, 0 );
zoom_slider->range( 1, 256 );
zoom_slider->value( 1 );
main_window->end();
main_window->show();