linuxaudio
/
new-session-manager
mirror of https://github.com/linuxaudio/new-session-manager
1
0
Fork 0
Code Issues 0 Releases 17 Wiki Activity
Browse Source

Ditch the whole separate Engine idea and move everything back to Timeline.

tags/non-daw-v1.1.0
Jonathan Moore Liles 17 years ago
parent
db29b21d2c
commit
0207dc9507
28 changed files with 42 additions and 1125 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -31
      Engine/Makefile
  2. +0
    -150
      Engine/Peak_Server.C
  3. +0
    -40
      Engine/Peak_Server.H
  4. +0
    -185
      Engine/Server.C
  5. +0
    -47
      Engine/Server.H
  6. +0
    -76
      Engine/Timeline_Server.C
  7. +0
    -40
      Engine/Timeline_Server.H
  8. +0
    -27
      Engine/const.h
  9. +0
    -77
      Engine/main.C
  10. +0
    -183
      Engine/objects.H
  11. +0
    -1
      Makefile
  12. +26
    -0
      Timeline/Audio_File.C
  13. +3
    -0
      Timeline/Audio_File.H
  14. +0
    -0
      Timeline/Audio_File_SF.C
  15. +0
    -0
      Timeline/Audio_File_SF.H
  16. +1
    -1
      Timeline/Audio_Track.C
  17. +0
    -70
      Timeline/Clip.H
  18. +0
    -0
      Timeline/Loggable.C
  19. +0
    -0
      Timeline/Loggable.H
  20. +4
    -2
      Timeline/Makefile
  21. +0
    -135
      Timeline/Peak_Client.C
  22. +0
    -40
      Timeline/Peak_Client.H
  23. +0
    -0
      Timeline/Peaks.C
  24. +0
    -0
      Timeline/Peaks.H
  25. +2
    -4
      Timeline/Region.C
  26. +5
    -5
      Timeline/Region.H
  27. +1
    -1
      Timeline/Waveform.H
  28. +0
    -10
      Timeline/main.C

+ 0
- 31
Engine/Makefile View File

@@ -1,31 +0,0 @@

SRCS= \
Server.C \
Peak_Server.C \
Timeline_Server.C \
main.C \
Audio_File.C \
Audio_File_SF.C \
Peaks.C \
Loggable.C \

OBJS=$(SRCS:.C=.o)

.PHONEY: all clean install dist valgrind

all: engine

$(OBJS): Makefile

include ../make.inc

engine: $(OBJS)
$(CXX) $(CXXFLAGS) $(INCLUDES) $(LIBS) $(OBJS) -o $@

clean:
rm -f $(OBJS) engine makedepend

valgrind:
valgrind ./test

include makedepend

+ 0
- 150
Engine/Peak_Server.C View File

@@ -1,150 +0,0 @@

/*******************************************************************************/
/* 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 "Peak_Server.H"

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>

/* Peak Server

The Peak Server streams peak data to any Timeline Editors or other
clients that ask for it.

Peak request looks like (in ASCII)

> read_peaks "foo.wav" fpp start end

Where "foo.wav" is the base name. (actual filenames may differ if
the channels of the source are 'broken out')

Response looks like (in binary)

> (int)channels (int)length (float)min max min max min max
> min max min max

Were length specifies the number of Peaks (min/max pairs) (for each
channel) The first channel is transmitted first, and any others
follow.
*/

#include "Audio_File.H"
#include "Peaks.H"

typedef unsigned long tick_t;

#define PEAK_PORT 6100

void
Peak_Server::handle_new ( int s )
{
printf( "new connection\n" );
}

void
Peak_Server::handle_hang_up ( int s )
{
printf( "hangup\n" );
}

void
Peak_Server::handle_request ( int s, const char *buf, int l )
{
printf( "request: %s", buf );

char source[512];
float fpp;
tick_t start, end;

enum { GET_INFO, READ_PEAKS } request;

if ( 1 == sscanf( buf, "get_info \"%[^\"]\"", source ) )
{
request = GET_INFO;
}
else if ( 4 == sscanf( buf, "read_peaks \"%[^\"]\" %f %lu %lu", source, &fpp, &start, &end ) )
{
request = READ_PEAKS;
}
else
{
const char *err = "error: malformed request\n";
fprintf( stderr, err );
send( s, err, strlen( err ), 0 );
return;
}

Audio_File *af = Audio_File::from_file( source );

if ( ! af )
{
const char *err = "error: could not open source\n";
send( s, err, strlen( err ), 0 );
return;
}

switch ( request )
{
case GET_INFO:
{
char buf[128];

snprintf( buf, sizeof( buf ), "length=%lu channels=%d\n", af->length(), af->channels() );

send( s, buf, strlen( buf ), 0 );

break;
}
case READ_PEAKS:
{

int data[2];
int peaks;

data[0] = af->channels();
data[1] = peaks = (end - start) / fpp;

send( s, &data, sizeof( data ), 0 );

const Peaks *pk = af->peaks();

int npeaks = pk->fill_buffer( fpp, start, end );

int channels = af->channels();

Peak *pbuf = new Peak[ npeaks * channels ];

/* deinterlace */
int k = 0;
for ( int i = 0; i < channels; i++ )
for ( int j = i; j < npeaks * channels; j += channels )
pbuf[ k++ ] = pk->peakbuf()[ j ];

/* transmit */
send( s, pbuf, sizeof( Peak ) * npeaks * channels, 0 );

delete pbuf;

break;
}
}

// delete af;
}

+ 0
- 40
Engine/Peak_Server.H View File

@@ -1,40 +0,0 @@

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

#include "Server.H"

class Peak_Server : public Server
{

protected:

void handle_new ( int s );
void handle_hang_up ( int s );
void handle_request ( int s, const char *s, int l );

public:

Peak_Server ( int port ) : Server ( port )
{
fork( true );
echo( false );
}
};

+ 0
- 185
Engine/Server.C View File

@@ -1,185 +0,0 @@

/*******************************************************************************/
/* 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 "Server.H"

#include <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/select.h>

/* Generic TCP server class */

/* */


#define MAX_HOST_NAME 512

/** open a socket listening on TCP port /port/. Returns -1 in case of error. */
int
Server::listen_on_port ( int port )
{
int s;
char name[ MAX_HOST_NAME + 1 ];
struct sockaddr_in sa;
struct hostent *hp;

memset( &sa, 0, sizeof( sa ) );
gethostname( name, MAX_HOST_NAME );
hp = gethostbyname( name );

sa.sin_family = hp->h_addrtype;
sa.sin_port = htons( port );
sa.sin_addr.s_addr = INADDR_ANY;

if ( ( s = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
{
printf( "Could not create command socket!" );
return -1;
}

int yes = 1;

if ( setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char * )&yes, sizeof( int ) ) < 0 )
{
close( s );
return -1;
}

if ( bind( s, (struct sockaddr *)&sa, sizeof( sa ) ) < 0 )
{
printf( "bind: %s", strerror( errno ) );
close( s );
return -1;
}

listen( s, 1 );

return s;
}

Server::Server ( int port )
{
_port = port;
_echo = false;
_fork = false;
}

void
Server::run ( void )
{
int server; /* server socket */

if ( ( server = listen_on_port( _port ) ) < 0 )
/* error */;

fd_set master;
fd_set read_fds;
int maxfd;

FD_ZERO( &master );
FD_ZERO( &read_fds );

FD_SET( server, &master );

maxfd = server;

for ( ;; )
{
read_fds = master;

if ( select( maxfd + 1, &read_fds, NULL, NULL, NULL ) == -1 )
{
perror( "select()" );
/* error */
}

/* service connections */
/* FIXME: there's a better way to do this than cover *all* fds. */
for ( int i = 2; i < maxfd + 1; ++i )
{
if ( FD_ISSET( i, &read_fds ) )
{
if ( i == server )
{
struct sockaddr_in ca;

socklen_t al = sizeof( ca );
int c;

if ( ( c = accept( server, (struct sockaddr *)&ca, &al ) ) < 0 )
perror( "accept()" );

FD_SET( c, &master );

if ( c > maxfd )
maxfd = c;

handle_new( c );
// printf( "New connection from %s on socket %d\n", inet_ntoa( ca.sin_addr ), c );
}
else
{
char buf[ BUFSIZ ];

int l;

if ( ( l = recv( i, buf, sizeof( buf ), 0 ) ) <= 0 )
{
if ( l == 0 )
{
handle_hang_up( i );
}
else
perror( "recv()" );

close( i );
FD_CLR( i, &master );
}
else
{

if ( echo() )
/* echo to others */
for ( int j = maxfd; j-- ; )
{
if ( ! FD_ISSET( j, &master ) )
continue;

if ( j != server && j != i )
{
if ( send( j, buf, l, 0 ) < 0 )
perror( "send()" );
}
}

buf[ l ] = '\0';
handle_request( i, buf, l );
}
}
}
}
}
}

+ 0
- 47
Engine/Server.H View File

@@ -1,47 +0,0 @@

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

class Server
{

int _port;
bool _echo;
bool _fork;

static int listen_on_port ( int port );

public:

Server ( int port );
void run ( void );

bool echo ( void ) { return _echo; }
bool fork ( void ) { return _fork; }
void echo ( bool b ) { _echo = b; }
void fork ( bool b) { _fork = b; }

protected:


virtual void handle_hang_up ( int s ) = 0;
virtual void handle_new ( int s ) = 0;
virtual void handle_request ( int s, const char *s, int l ) = 0;
};

+ 0
- 76
Engine/Timeline_Server.C View File

@@ -1,76 +0,0 @@

/*******************************************************************************/
/* 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 "objects.H"

/* #include <sys/socket.h> */
/* #include <sys/types.h> */
/* #include <sys/select.h> */

#include "Timeline_Server.H"

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>

/* Timeline Server.

The timeline server runs in its own thread and manages communication
between the engine and any connected timeline editors.

Its duties are as follows:

* Listen for connections from Timeline Editors on a TCP port.

* Accept 'do' messages from each connection, echoing the change to
all others.

* Keep global engine state in sync with recieved messages (in a
lock-free manner)

* Write do+undo messages to journal.

* Translate "undo" command into the appropriate 'do' messages.

*/


#define TIMELINE_PORT 6100

void
Timeline_Server::handle_new ( int s )
{
printf( "new connection\n" );
}

void
Timeline_Server::handle_hang_up ( int s )
{
printf( "hangup\n" );
}

void
Timeline_Server::handle_request ( int s, const char *buf, int l )
{
printf( "request: %s", buf );

// Loggable::do( buf );

send( s, "fuckoff\n", strlen( "fuckoff\n" ), 0 );
}

+ 0
- 40
Engine/Timeline_Server.H View File

@@ -1,40 +0,0 @@

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

#include "Server.H"

class Timeline_Server : public Server
{

protected:

void handle_new ( int s );
void handle_hang_up ( int s );
void handle_request ( int s, const char *s, int l );

public:

Timeline_Server ( int port ) : Server ( port )
{
fork( false );
echo( true );
}
};

+ 0
- 27
Engine/const.h View File

@@ -1,27 +0,0 @@

/*******************************************************************************/
/* 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. */
/*******************************************************************************/






/* default peak file resolution, therefore normally any zoom level less than this will
require reading from the audio files directly */
const int FRAMES_PER_PEAK = 256;

+ 0
- 77
Engine/main.C View File

@@ -1,77 +0,0 @@

/*******************************************************************************/
/* 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 "const.h"
#include "Audio_File.H"
#include "Peaks.H"
#include "Loggable.H"



#include "Timeline_Server.H"
#include "Peak_Server.H"

/* TODO:

Run server process here.

* Manage session file.
* Keep state for all relevant objects (must mirror that in Timeline)
* Listen for incoming connections.
* Send and recieve 'do' messages to client(s), recording do and undo portions to journal. Serve peaks (maybe in a separate process?)

Peak request looks like:

> read_peaks "foo.wav" fpp start end

Response looks like (in binary floats):

> length min max min max min max


State must be communicated to realtime thread locklessly so that:

Realtime:

* Manage JACK transport.
* Manage JACK outputs.
* Stream regions from disk.
* Manage JACK inputs.
* Stream tracks to disk when recording.
* Stream control points as OSC messages. (RT safe?)
*/

int
main ( int argc, char **argv )
{

if ( ! fork() )
{
Peak_Server pks( 6111 );

pks.run();
exit( 0 );
}

Timeline_Server tls( 6110 );

tls.run();

}

+ 0
- 183
Engine/objects.H View File

@@ -1,183 +0,0 @@

/*******************************************************************************/
/* 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. */
/*******************************************************************************/

/* these are all the objects whose state must be recorded, this
includes tracks, regions, etc. Relevant interfaces must be fully compatible
with those in the Timeline program. */

#include "Audio_File.H"
#include "Loggable.H"

typedef unsigned long nframes_t;

class Track_Widget
{

protected:

nframes_t _offset;
nframes_t _start;
nframes_t _end;
bool _selected;

};

/* macros to simplify serialization code */
#define START( n ) char **sa = (char **)malloc( sizeof( char * ) * (1 + (n) ) ); int i = 0
#define PUT( fmt, arg ) asprintf( &sa[ i++ ], (fmt), (arg) )
#define END() sa[ i ] = NULL; return sa;

#define SWITCH do
#define CASE( arg ) if ( ! strcmp( s, ( arg ) ) )
#define GET( arg, act ) CASE( arg ) { act ; break; }


class Track : public Loggable
{



};

class Region : public Loggable, public Track_Widget
{

Track *_track;
Audio_File *_clip; /* clip this region represents */
float _scale; /* amplitude adjustment */

protected:

const char *class_name ( void ) { return "Region"; }

char ** get ( void )
{
START( 7 );

PUT( ":source \"%s\"", _clip ? _clip->name() : "" );
PUT( ":track 0x%X", _track ? _track->id() : 0 );
PUT( ":x %lu", _offset );
PUT( ":l %lu", _start );
PUT( ":r %lu", _end );
PUT( ":selected %d", _selected );
PUT( ":gain %f", _scale );

END();
}

void
set ( char **sa )
{
for ( int i = 0; sa[i]; ++i )
{
char *s = sa[i];
char *v = s + strlen( s ) + 1;

SWITCH
{
GET( ":x", _offset = atol( v ) );
GET( ":l" , _start = atol( v ) );
GET( ":r", _end = atol( v ) );
CASE( ":selected" )
{
if ( atoi( v ) )
select();
else
deselect();

break;
}
GET( ":gain", _scale = atof( v ) );
CASE( ":source" )
{
if ( ! ( _clip = Audio_File::from_file( v ) ) )
printf( "Grave error: could not open source \"%s\"\n", v );
break;
}
CASE( ":track" )
{
int i;
sscanf( v, "%X", &i );
Track *t = (Track*)Loggable::find( i );

assert( t );

t->add( this );
break;
}
}


free( s );
}

free( sa );
}
};


class Time_Point : public Track_Widget
{

protected:

char ** get ( void )
{
START( 4 );

PUT( ":track 0x%X", _track ? _track->id() : 0 );
PUT( ":x %lu", _offset );
PUT( ":beats_per_bar %d", _time.beats_per_bar );
PUT( ":beat_type %d", _time.beat_type );

END();
}

void
set ( char **sa )
{
for ( int i = 0; sa[i]; ++i )
{
char *s = sa[i];
char *v = s + strlen( s ) + 1;

SWITCH
{
GET( ":x", _offset = atol( v ) );
GET( ":beats_per_bar", _time.beats_per_bar = atoi( v ) );
GET( ":beat_type", _time.beat_type = atoi( v ) );
CASE( ":track" )
{
int i;
sscanf( v, "%X", &i );
Track *t = (Track*)Loggable::find( i );

assert( t );

t->add( this );
break;
}

free( s );
}

free( sa );
}
}
};

+ 0
- 1
Makefile View File

@@ -5,7 +5,6 @@ LIBS := -lsndfile `fltk-config --ldflags`
all: all

%:
@ $(MAKE) -s -C Engine CXXFLAGS="$(CXXFLAGS)" LIBS="$(LIBS)" $@
@ $(MAKE) -s -C FL CXXFLAGS="$(CXXFLAGS)" LIBS="$(LIBS)" $@
@ $(MAKE) -s -C Timeline CXXFLAGS="$(CXXFLAGS)" LIBS="$(LIBS)" $@
@ $(MAKE) -s -C Mixer CXXFLAGS="$(CXXFLAGS)" LIBS="$(LIBS)" $@

Engine/Audio_File.C → Timeline/Audio_File.C View File

@@ -50,3 +50,29 @@ done:

return a;
}


bool
Audio_File::read_peaks( float fpp, nframes_t start, nframes_t end, int *peaks, Peak **pbuf, int *channels )
{
Peaks pk;

pk.clip( this );

if ( ! pk.open() )
return false;

*peaks = pk.fill_buffer( fpp, start, end );

*channels = this->channels();

*pbuf = new Peak[ *peaks * *channels ];

/* deinterlace */
int k = 0;
for ( int i = 0; i < *channels; i++ )
for ( int j = i; j < *peaks * *channels; j += *channels )
(*pbuf)[ k++ ] = pk.peakbuf()[ j ];

return true;
}

Engine/Audio_File.H → Timeline/Audio_File.H View File

@@ -67,4 +67,7 @@ public:
virtual nframes_t read ( sample_t *buf, int channel, nframes_t len ) = 0;
virtual nframes_t read ( sample_t *buf, int channel, nframes_t start, nframes_t end ) = 0;

bool read_peaks( float fpp, nframes_t start, nframes_t end, int *peaks, Peak **pbuf, int *channels );


};

Engine/Audio_File_SF.C → Timeline/Audio_File_SF.C View File


Engine/Audio_File_SF.H → Timeline/Audio_File_SF.H View File


+ 1
- 1
Timeline/Audio_Track.C View File

@@ -88,7 +88,7 @@ Audio_Track::handle ( int m )
fl_cursor( FL_CURSOR_WAIT );
Fl::check();

Clip *c = Clip::from_file( file );
Audio_File *c = Audio_File::from_file( file );

fl_cursor( FL_CURSOR_DEFAULT );



+ 0
- 70
Timeline/Clip.H View File

@@ -1,70 +0,0 @@

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

/* a clip is just a stupid wrapper object for communicating with the peak server */

#include "Peak_Client.H"
extern Peak_Client peak_client;

class Clip
{
const char *_filename;
nframes_t _length; /* length of file in samples */
int _channels;

public:

Clip ( )
{
_filename = NULL;
_length = _channels = 0;
}

const char *name ( void ) const { return _filename; }
nframes_t length ( void ) const { return _length; }
int channels ( void ) const { return _channels; }

static Clip *
from_file ( const char * filename )
{

Clip *c = new Clip;

c->_filename = filename;

if ( ! peak_client.get_info( filename, &c->_length, &c->_channels ) )
{
delete c;
return false;
}

return c;
}

bool
read_peaks ( float fpp, nframes_t start, nframes_t end,
int *peaks, Peak **pbuf, int *channels )
{
return peak_client.read_peaks( _filename, fpp, start, end, peaks, pbuf, channels );
}
};

Engine/Loggable.C → Timeline/Loggable.C View File


Engine/Loggable.H → Timeline/Loggable.H View File


+ 4
- 2
Timeline/Makefile View File

@@ -8,8 +8,10 @@ SRCS= \
Timeline.C \
Track_Header.C \
Track_Widget.C \
Peak_Client.C \
../Engine/Loggable.C \
Peaks.C \
Audio_File.C \
Audio_File_SF.C \
Loggable.C \

OBJS=$(SRCS:.C=.o)



+ 0
- 135
Timeline/Peak_Client.C View File

@@ -1,135 +0,0 @@

/*******************************************************************************/
/* 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 <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/select.h>


#include "Peak_Client.H"

/* An interface to the peak server */

#define PEAK_PORT 6111

int
connect_to_host ( const char *host, int port )
{
int s;
struct sockaddr_in sa;
struct hostent *hp;

memset( &sa, 0, sizeof( sa ) );

hp = gethostbyname( host );

sa.sin_family = hp->h_addrtype;
sa.sin_port = htons( port );
sa.sin_addr.s_addr = INADDR_ANY;

if ( ( s = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
{
perror( "socket()" );
return -1;
}

if ( connect( s, (struct sockaddr *)&sa, sizeof( sa ) ) < 0 )
{
perror( "connect()" );
close( s );
return -1;
}

return s;
}

bool
Peak_Client::connect ( const char *host )
{

if ( ( _socket = connect_to_host( host, PEAK_PORT ) ) < 0 )
return false;

return true;
}

bool
Peak_Client::get_info ( const char *source, nframes_t *len, int *channels )
{

/* FIXME: needs to handle errors/reconnect */
char buf[512];

snprintf( buf, sizeof( buf ), "get_info \"%s\"\n", source );

send( _socket, buf, strlen( buf ), 0 );

recv( _socket, buf, sizeof( buf ), 0 );

if ( sscanf( buf, "length=%lu channels=%d", len, channels ) != 2 )
return false;

return true;
}

bool
Peak_Client::read_peaks ( const char *source, float fpp, nframes_t start, nframes_t end,
int *peaks, Peak **pbuf, int *channels )
{

/* FIXME: needs to handle errors/reconnect */
char buf[512];

snprintf( buf, sizeof( buf ), "read_peaks \"%s\" %f %lu %lu\n", source, fpp, start, end );

send( _socket, buf, strlen( buf ), 0 );

if ( recv( _socket, buf, sizeof( int ) * 2, 0 ) != sizeof( int ) * 2 )
{
printf( "error!\n" );
return false;
}

if ( ! strncmp( buf, "error", 5 ) )
return false;

*channels = ((int*)buf)[0];
*peaks = ((int*)buf)[1];

if ( ! ( *peaks && *channels ) )
/* unknown error */;

printf( "reading %d peaks for %d channels\n", *peaks, *channels );

*pbuf = new Peak[ *peaks * *channels ];

for ( int i = 0; i < *channels; ++i )
recv( _socket, *pbuf + (i * *peaks), *peaks * sizeof( Peak ), MSG_WAITALL );

printf( "done.\n" );

return true;
}

+ 0
- 40
Timeline/Peak_Client.H View File

@@ -1,40 +0,0 @@

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

int connect_to_host ( const char *host, int port );
typedef unsigned long nframes_t;

struct Peak {
float min, max;
};

class Peak_Client
{

int _socket;

public:

bool connect ( const char *host );
bool get_info ( const char *source, nframes_t *len, int *channels );
bool read_peaks ( const char *source, float fpp, nframes_t start, nframes_t end, int *peaks, Peak **pbuf, int *channels );

};

Engine/Peaks.C → Timeline/Peaks.C View File


Engine/Peaks.H → Timeline/Peaks.H View File


+ 2
- 4
Timeline/Region.C View File

@@ -35,8 +35,6 @@
using namespace std;


#include "Peak_Client.H"

extern Timeline *timeline;

Fl_Boxtype Region::_box = FL_UP_BOX;
@@ -110,7 +108,7 @@ Region::Region ( const Region & rhs )
}

/* */
Region::Region ( Clip *c )
Region::Region ( Audio_File *c )
{
init();
_clip = c;
@@ -121,7 +119,7 @@ Region::Region ( Clip *c )


/* used when DND importing */
Region::Region ( Clip *c, Track *t, nframes_t o )
Region::Region ( Audio_File *c, Track *t, nframes_t o )
{
init();
_clip = c;


+ 5
- 5
Timeline/Region.H View File

@@ -18,7 +18,7 @@
/*******************************************************************************/
#pragma once

#include "Clip.H"
#include "Audio_File.H"
#include "Track.H"
#include "Timeline.H"

@@ -38,7 +38,7 @@ class Region_Base : public Track_Widget

private:

Clip *_clip; /* clip this region represents */
Audio_File *_clip; /* clip this region represents */

float _scale; /* amplitude adjustment */

@@ -100,7 +100,7 @@ protected:
_scale = atof( v );
else if ( ! strcmp( s, ":source" ) )
{
if ( ! ( _clip = Clip::from_file( v ) ) )
if ( ! ( _clip = Audio_File::from_file( v ) ) )
{
printf( "Grave error: could not open source \"%s\"\n", v );
}
@@ -194,8 +194,8 @@ public:
Fl_Align align ( void ) const { return (Fl_Align)(FL_ALIGN_LEFT | FL_ALIGN_BOTTOM /*| FL_ALIGN_CLIP*/ | FL_ALIGN_INSIDE); }

Region ( const Region & rhs );
Region ( Clip *c );
Region ( Clip *c, Track *t, nframes_t o );
Region ( Audio_File *c );
Region ( Audio_File *c, Track *t, nframes_t o );

int handle ( int m );
void draw_box( int X, int Y, int W, int H );


+ 1
- 1
Timeline/Waveform.H View File

@@ -24,7 +24,7 @@

#include "Timeline.H"

#include "Peak_Client.H"
#include "Peaks.H"

class Waveform {



+ 0
- 10
Timeline/main.C View File

@@ -53,10 +53,6 @@

Timeline *timeline;

#include "Peak_Client.H"

Peak_Client peak_client;

void cb_undo ( Fl_Widget *w, void *v )
{
Loggable::undo();
@@ -74,12 +70,6 @@ main ( int argc, char **argv )
// Fl::scheme( "gtk+" );


if ( ! peak_client.connect( "localhost" ) )
{
fprintf( stderr, "Could not connect to peak server!\n" );
return 1;
}

Loggable::open( "history" );
/* welcome to C++ */
Loggable::register_create( "Region", &Region::create );


Write Preview
Loading…
Cancel
Save