Browse Source

Work on supporting actual audio backing. WIP.

tags/non-daw-v1.1.0
Jonathan Moore Liles 16 years ago
parent
commit
41b62781d1
10 changed files with 308 additions and 90 deletions
  1. +50
    -0
      Clip.H
  2. +5
    -1
      Makefile
  3. +106
    -0
      Peaks.C
  4. +57
    -0
      Peaks.H
  5. +14
    -3
      Region.C
  6. +3
    -0
      Region.H
  7. +2
    -0
      Timeline.H
  8. +32
    -60
      Waveform.C
  9. +17
    -4
      Waveform.H
  10. +22
    -22
      main.C

+ 50
- 0
Clip.H 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; }
};

+ 5
- 1
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
- 0
Peaks.C 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
- 0
Peaks.H 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;

};

+ 14
- 3
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
- 0
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
- 0
Timeline.H View File

@@ -26,3 +26,5 @@ struct Timeline {

float fpp; /* frames per pixel */
};

extern Timeline timeline;

+ 32
- 60
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 ) ) );

hi *= _scale;
lo *= _scale;
p.max *= _scale;
p.min *= _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();
}

+ 17
- 4
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 );

};

+ 22
- 22
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" );

FILE *fp;

fp = fopen( "peaks", "r" );
// Region *wave = new Region( 0, 0, 5000, 100, "foo" );

struct stat st;
Region *wave = new Region( new Clip( "foo.wav" ) );

fstat( fileno( fp ), &st );
wave->resize( 0, 0, 500, 100 );

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



Loading…
Cancel
Save