Work on supporting actual audio backing. WIP.

Clip.H

@@ -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; }
+};

Makefile

@@ -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

Peaks.C

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

Peaks.H

@@ -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;
+
+};

Region.C

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

Region.H

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

Timeline.H

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

Waveform.C

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

Waveform.H

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

main.C

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