jackaudio
/
jack1
mirror of https://github.com/jackaudio/jack1
1
0
Fork 0
Code Releases 19 Activity
Browse Source

Use jack_info instead of printf 

git-svn-id: svn+ssh://jackaudio.org/trunk/jack@1097 0c269be4-1314-0410-8aa9-9f06e86f4224
tags/0.115.6
sletz 18 years ago
parent
280620f6e0
commit
e51afa7f5c
2 changed files with 94 additions and 119 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +94
    -118
      drivers/netjack/net_driver.c
  2. +0
    -1
      drivers/netjack/net_driver.h

+ 94
- 118
drivers/netjack/net_driver.c View File

@@ -23,7 +23,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
$Id: net_driver.c,v 1.17 2006/04/16 20:16:10 torbenh Exp $
*/


#include <math.h>
#include <stdio.h>
#include <memory.h>
@@ -35,7 +34,6 @@ $Id: net_driver.c,v 1.17 2006/04/16 20:16:10 torbenh Exp $
#include <sys/poll.h>

#include <jack/types.h>
//#include <jack/internal.h>
#include <jack/engine.h>
#include <sysdeps/time.h>

@@ -55,18 +53,16 @@ static jack_transport_state_t last_transport_state;
static int framecnt; // this is set upon reading a packet.
// and will be written into the pkthdr of an outgoing packet.




static int
net_driver_sync_cb( jack_transport_state_t state, jack_position_t *pos, net_driver_t *driver )
net_driver_sync_cb(jack_transport_state_t state, jack_position_t *pos, net_driver_t *driver)
{
int retval = sync_state;

if ( state == JackTransportStarting && last_transport_state != JackTransportStarting ) {
if (state == JackTransportStarting && last_transport_state != JackTransportStarting) {
retval = 0;
}
if ( state == JackTransportStarting ) printf( "Starting sync_state = %d\n", sync_state );
if (state == JackTransportStarting)
jack_info("Starting sync_state = %d", sync_state);
last_transport_state = state;
return retval;
}
@@ -87,7 +83,7 @@ net_driver_wait (net_driver_t *driver, int extra_fd, int *status,
#if 0
fd_set read_fds;
int res = 0;
while ( res == 0) {
while (res == 0) {
FD_ZERO(&read_fds);
FD_SET(driver->sockfd, &read_fds);
res = select(driver->sockfd + 1, &read_fds, NULL, NULL, NULL); // wait here until there is a packet to get
@@ -96,27 +92,26 @@ net_driver_wait (net_driver_t *driver, int extra_fd, int *status,

socklen_t address_size = sizeof(struct sockaddr_in);

int bufsize = get_sample_size( driver->bitdepth ) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);
int bufsize = get_sample_size(driver->bitdepth) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);

jacknet_packet_header *pkthdr = (jacknet_packet_header *)driver->rx_buf;

rx_again:
if ( !driver->srcaddress_valid ) {
if (!driver->srcaddress_valid) {
// XXX: Somthings really bad ;)
puts("!driver->srcaddress_valid");
return 0;
}
int len = netjack_recvfrom( driver->sockfd, (char *)driver->rx_buf, bufsize,
MSG_WAITALL, (struct sockaddr*) & driver->syncsource_address, &address_size, 1400 );
int len = netjack_recvfrom(driver->sockfd, (char *)driver->rx_buf, bufsize,
MSG_WAITALL, (struct sockaddr*) & driver->syncsource_address, &address_size, 1400);


if (len != bufsize) {
printf( "wrong_packet_len: len=%d, expected=%d\n", len, bufsize );
jack_info("wrong_packet_len: len=%d, expected=%d", len, bufsize);
goto rx_again;
}

packet_header_ntoh( pkthdr );

packet_header_ntoh(pkthdr);

//driver->srcaddress_valid = 0;

@@ -149,7 +144,7 @@ net_driver_run_cycle (net_driver_t *driver)
if (nframes == 0) {
/* we detected an xrun and restarted: notify
* clients about the delay. */
engine->delay (engine, delayed_usecs );
engine->delay (engine, delayed_usecs);
return 0;
}
#endif
@@ -166,11 +161,11 @@ net_driver_run_cycle (net_driver_t *driver)
static int
net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)
{
//int rx_size = get_sample_size( driver->bitdepth ) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);
int tx_size = get_sample_size( driver->bitdepth ) * driver->playback_channels * driver->net_period_up + sizeof(jacknet_packet_header);
//int rx_size = get_sample_size(driver->bitdepth) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);
int tx_size = get_sample_size(driver->bitdepth) * driver->playback_channels * driver->net_period_up + sizeof(jacknet_packet_header);
unsigned int *packet_buf, *packet_bufX;

packet_buf = alloca( tx_size );
packet_buf = alloca( tx_size);
jacknet_packet_header *tx_pkthdr = (jacknet_packet_header *)packet_buf;
jacknet_packet_header *rx_pkthdr = (jacknet_packet_header *)driver->rx_buf;

@@ -178,8 +173,6 @@ net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)

driver->reply_port = rx_pkthdr->reply_port;



// offset packet_bufX by the packetheader.
packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);

@@ -188,16 +181,16 @@ net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)
tx_pkthdr->framecnt = framecnt;

// memset 0 the payload.
int payload_size = get_sample_size( driver->bitdepth ) * driver->playback_channels * driver->net_period_up;
memset( packet_bufX, 0, payload_size );
int payload_size = get_sample_size(driver->bitdepth) * driver->playback_channels * driver->net_period_up;
memset(packet_bufX, 0, payload_size);

packet_header_hton( tx_pkthdr );
if ( driver->srcaddress_valid )
if ( driver->reply_port )
driver->syncsource_address.sin_port = htons( driver->reply_port );
packet_header_hton(tx_pkthdr);
if (driver->srcaddress_valid)
if (driver->reply_port)
driver->syncsource_address.sin_port = htons(driver->reply_port);

netjack_sendto( driver->outsockfd, (char *)packet_buf, tx_size,
0, (struct sockaddr*)&driver->syncsource_address, sizeof(struct sockaddr_in), 1400 );
netjack_sendto(driver->outsockfd, (char *)packet_buf, tx_size,
0, (struct sockaddr*)&driver->syncsource_address, sizeof(struct sockaddr_in), 1400);

return 0;
}
@@ -205,7 +198,7 @@ net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)
static int
net_driver_bufsize (net_driver_t* driver, jack_nframes_t nframes)
{
if ( nframes != driver->period_size )
if (nframes != driver->period_size)
return EINVAL;

return 0;
@@ -219,72 +212,65 @@ net_driver_read (net_driver_t* driver, jack_nframes_t nframes)
jack_position_t local_trans_pos;
jack_transport_state_t local_trans_state;

//int bufsize = get_sample_size( driver->bitdepth ) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);
//int bufsize = get_sample_size(driver->bitdepth) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);
unsigned int *packet_buf, *packet_bufX;

packet_buf = driver->rx_buf;

jacknet_packet_header *pkthdr = (jacknet_packet_header *)packet_buf;



packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);

//packet_header_ntoh( pkthdr );


//packet_header_ntoh(pkthdr);
// fill framecnt from pkthdr.

if ( pkthdr->framecnt != framecnt + 1 )
printf( "bogus framecount %d\n", pkthdr->framecnt );
if (pkthdr->framecnt != framecnt + 1)
jack_info("bogus framecount %d", pkthdr->framecnt);

framecnt = pkthdr->framecnt;
driver->reply_port = pkthdr->reply_port;


// check whether, we should handle the transport sync stuff, or leave trnasports untouched.

if ( driver->handle_transport_sync ) {
if (driver->handle_transport_sync) {

// read local transport info....
local_trans_state = jack_transport_query( driver->client, &local_trans_pos );

local_trans_state = jack_transport_query(driver->client, &local_trans_pos);

// Now check if we have to start or stop local transport to sync to remote...
switch ( pkthdr->transport_state ) {
switch (pkthdr->transport_state) {
case JackTransportStarting:
// the master transport is starting... so we set our reply to the sync_callback;
if ( local_trans_state == JackTransportStopped ) {
jack_transport_start( driver->client );
if (local_trans_state == JackTransportStopped) {
ja(ck_transport_start(driver->client);
last_transport_state = JackTransportStopped;
sync_state = FALSE;
printf( "locally stopped... starting... \n" );
jack_info("locally stopped... starting...");
}

if ( local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * nframes ) ) {
jack_transport_locate( driver->client, (pkthdr->transport_frame + (pkthdr->latency) * nframes ) );
if (local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * nframes)) {
jack_transport_locate(driver->client, (pkthdr->transport_frame + (pkthdr->latency) * nframes));
last_transport_state = JackTransportRolling;
sync_state = FALSE;
printf( "starting locate to %d\n", pkthdr->transport_frame + (pkthdr->latency)*nframes);
jack_info("starting locate to %d", pkthdr->transport_frame + (pkthdr->latency)*nframes);
}
break;
case JackTransportStopped:
sync_state = TRUE;
if ( local_trans_pos.frame != (pkthdr->transport_frame) ) {
jack_transport_locate( driver->client, (pkthdr->transport_frame ) );
printf( "transport is stopped locate to %d\n", pkthdr->transport_frame);
if (local_trans_pos.frame != (pkthdr->transport_frame)) {
jack_transport_locate(driver->client, (pkthdr->transport_frame));
jack_info("transport is stopped locate to %d", pkthdr->transport_frame);
}
if ( local_trans_state != JackTransportStopped )
jack_transport_stop( driver->client );
if (local_trans_state != JackTransportStopped)
jack_transport_stop(driver->client);
break;
case JackTransportRolling:
sync_state = TRUE;
// if( local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * nframes ) ) {
// jack_transport_locate( driver->client, (pkthdr->transport_frame + (pkthdr->latency + 2) * nframes ) );
// printf( "running locate to %d\n", pkthdr->transport_frame + (pkthdr->latency)*nframes);
// if(local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * nframes)) {
// jack_transport_locate(driver->client, (pkthdr->transport_frame + (pkthdr->latency + 2) * nframes));
// jack_info("running locate to %d", pkthdr->transport_frame + (pkthdr->latency)*nframes);
// }
if ( local_trans_state != JackTransportRolling )
jack_transport_start( driver->client );
if (local_trans_state != JackTransportRolling)
jack_transport_start(driver->client);
break;

case JackTransportLooping:
@@ -293,7 +279,7 @@ net_driver_read (net_driver_t* driver, jack_nframes_t nframes)
}


render_payload_to_jack_ports( driver->bitdepth, packet_bufX, driver->net_period_down, driver->capture_ports, driver->capture_srcs, nframes );
render_payload_to_jack_ports(driver->bitdepth, packet_bufX, driver->net_period_down, driver->capture_ports, driver->capture_srcs, nframes);

return 0;
}
@@ -303,9 +289,9 @@ net_driver_write (net_driver_t* driver, jack_nframes_t nframes)
{
uint32_t *packet_buf, *packet_bufX;

int packet_size = get_sample_size( driver->bitdepth ) * driver->playback_channels * driver->net_period_up + sizeof(jacknet_packet_header);
int packet_size = get_sample_size(driver->bitdepth) * driver->playback_channels * driver->net_period_up + sizeof(jacknet_packet_header);

packet_buf = alloca( packet_size );
packet_buf = alloca(packet_size);

jacknet_packet_header *pkthdr = (jacknet_packet_header *)packet_buf;

@@ -315,14 +301,14 @@ net_driver_write (net_driver_t* driver, jack_nframes_t nframes)
pkthdr->sync_state = (driver->engine->control->sync_remain <= 1);
pkthdr->framecnt = framecnt;

render_jack_ports_to_payload( driver->bitdepth, driver->playback_ports, driver->playback_srcs, nframes, packet_bufX, driver->net_period_up );
render_jack_ports_to_payload(driver->bitdepth, driver->playback_ports, driver->playback_srcs, nframes, packet_bufX, driver->net_period_up);

packet_header_hton( pkthdr );
if ( driver->srcaddress_valid )
if ( driver->reply_port )
driver->syncsource_address.sin_port = htons( driver->reply_port );
netjack_sendto( driver->outsockfd, (char *)packet_buf, packet_size,
0, (struct sockaddr*)&driver->syncsource_address, sizeof(struct sockaddr_in), 1400 );
packet_header_hton(pkthdr);
if (driver->srcaddress_valid)
if (driver->reply_port)
driver->syncsource_address.sin_port = htons(driver->reply_port);
netjack_sendto(driver->outsockfd, (char *)packet_buf, packet_size,
0, (struct sockaddr*)&driver->syncsource_address, sizeof(struct sockaddr_in), 1400);

return 0;
}
@@ -340,8 +326,8 @@ net_driver_attach (net_driver_t *driver)
driver->engine->set_buffer_size (driver->engine, driver->period_size);
driver->engine->set_sample_rate (driver->engine, driver->sample_rate);

if ( driver->handle_transport_sync )
jack_set_sync_callback( driver->client, (JackSyncCallback) net_driver_sync_cb, driver );
if (driver->handle_transport_sync)
jack_set_sync_callback(driver->client, (JackSyncCallback) net_driver_sync_cb, driver);

port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

@@ -358,7 +344,7 @@ net_driver_attach (net_driver_t *driver)

driver->capture_ports =
jack_slist_append (driver->capture_ports, port);
driver->capture_srcs = jack_slist_append( driver->capture_srcs, src_new( SRC_LINEAR, 1, NULL ) );
driver->capture_srcs = jack_slist_append(driver->capture_srcs, src_new(SRC_LINEAR, 1, NULL));
}

port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
@@ -377,11 +363,10 @@ net_driver_attach (net_driver_t *driver)

driver->playback_ports =
jack_slist_append (driver->playback_ports, port);
driver->playback_srcs = jack_slist_append( driver->playback_srcs, src_new( SRC_LINEAR, 1, NULL ) );
driver->playback_srcs = jack_slist_append(driver->playback_srcs, src_new(SRC_LINEAR, 1, NULL));
}

jack_activate (driver->client);

return 0;
}

@@ -411,7 +396,6 @@ net_driver_detach (net_driver_t *driver)
return 0;
}


static void
net_driver_delete (net_driver_t *driver)
{
@@ -430,13 +414,13 @@ net_driver_new (jack_client_t * client,
unsigned int transport_sync,
unsigned int resample_factor,
unsigned int resample_factor_up,
unsigned int bitdepth )
unsigned int bitdepth)
{
net_driver_t * driver;
struct sockaddr_in address;

printf ("creating net driver ... %s|%" PRIu32 "|%" PRIu32
"|%u|%u|%u|transport_sync:%u\n", name, sample_rate, period_size, listen_port,
jack_info("creating net driver ... %s|%" PRIu32 "|%" PRIu32
"|%u|%u|%u|transport_sync:%u", name, sample_rate, period_size, listen_port,
capture_ports, playback_ports, transport_sync);

driver = (net_driver_t *) calloc (1, sizeof (net_driver_t));
@@ -470,65 +454,64 @@ net_driver_new (jack_client_t * client,
driver->client = client;
driver->engine = NULL;

if ( (bitdepth != 0) && (bitdepth != 8) && (bitdepth != 16) ) {
printf( "Invalid bitdepth: %d (8,16 or 0 for float) !!!\n", bitdepth );
if ((bitdepth != 0) && (bitdepth != 8) && (bitdepth != 16)) {
jack_info("Invalid bitdepth: %d (8,16 or 0 for float) !!!", bitdepth);
return NULL;
}
driver->bitdepth = bitdepth;


if ( resample_factor_up == 0 )
if (resample_factor_up == 0)
resample_factor_up = resample_factor;

// Now open the socket, and wait for the first packet to arrive...


driver->sockfd = socket( PF_INET, SOCK_DGRAM, 0 );
if ( driver->sockfd == -1 ) {
printf( "socket error\n" );
driver->sockfd = socket(PF_INET, SOCK_DGRAM, 0);
if (driver->sockfd == -1) {
jack_info("socket error");
return NULL;
}
address.sin_family = AF_INET;
address.sin_port = htons( driver->listen_port );
address.sin_addr.s_addr = htonl( INADDR_ANY );
if ( bind( driver->sockfd, (struct sockaddr *) &address, sizeof(address) ) < 0 ) {
printf( "bind error\n" );
address.sin_port = htons(driver->listen_port);
address.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(driver->sockfd, (struct sockaddr *) &address, sizeof(address)) < 0) {
jack_info("bind error");
return NULL;
}

driver->outsockfd = socket( PF_INET, SOCK_DGRAM, 0 );
if ( driver->sockfd == -1 ) {
printf( "socket error\n" );
driver->outsockfd = socket(PF_INET, SOCK_DGRAM, 0);
if (driver->sockfd == -1) {
jack_info("socket error");
return NULL;
}
driver->srcaddress_valid = 0;

jacknet_packet_header *first_packet = alloca( sizeof(jacknet_packet_header) );
jacknet_packet_header *first_packet = alloca(sizeof(jacknet_packet_header));
socklen_t address_size = sizeof(struct sockaddr_in);

printf( "Waiting for an incoming packet !!!\n\n" );
printf( "*** IMPORTANT ***\n Dont connect a client to jackd until the driver is attached to a clock source !!!\n" );

jack_info("Waiting for an incoming packet !!!");
jack_info("*** IMPORTANT *** Dont connect a client to jackd until the driver is attached to a clock source !!!");

int first_pack_len = recvfrom( driver->sockfd, first_packet, sizeof(jacknet_packet_header), 0, (struct sockaddr*) & driver->syncsource_address, &address_size );
int first_pack_len = recvfrom(driver->sockfd, first_packet, sizeof(jacknet_packet_header), 0, (struct sockaddr*) & driver->syncsource_address, &address_size);
driver->srcaddress_valid = 1;

printf( "first_pack_len=%d\n", first_pack_len );
jack_info("first_pack_len=%d", first_pack_len);
// A packet is here.... If it wasnt the old trigger packet containing only 'x' evaluate the autoconf data...

driver->mtu = 0;

if ( first_pack_len == sizeof(jacknet_packet_header) ) {
packet_header_ntoh( first_packet );
if (first_pack_len == sizeof(jacknet_packet_header)) {
packet_header_ntoh(first_packet);

printf("AutoConfig Override !!!\n" );
if ( driver->sample_rate != first_packet->sample_rate ) {
printf("AutoConfig Override: sample_rate = %d\n", first_packet->sample_rate );
jack_info("AutoConfig Override !!!");
if (driver->sample_rate != first_packet->sample_rate) {
jack_info("AutoConfig Override: sample_rate = %d", first_packet->sample_rate);
driver->sample_rate = first_packet->sample_rate;
}

if ( driver->period_size != first_packet->period_size ) {
printf("AutoConfig Override: period_size = %d\n", first_packet->period_size );
if (driver->period_size != first_packet->period_size) {
jack_info("AutoConfig Override: period_size = %d", first_packet->period_size);
driver->period_size = first_packet->period_size;
}

@@ -542,26 +525,21 @@ net_driver_new (jack_client_t * client,
(jack_time_t) floor ((((float) driver->period_size) / driver->sample_rate)
* 1000000.0f);



driver->net_period_down = (float) driver->period_size / (float) resample_factor;
driver->net_period_up = (float) driver->period_size / (float) resample_factor_up;

driver->rx_buf = malloc( sizeof(jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size( driver->bitdepth ) );
driver->rx_buf = malloc(sizeof(jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size(driver->bitdepth));

// XXX: dont need it when packet size < mtu
driver->pkt_buf = malloc( sizeof(jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size( driver->bitdepth ) );

int rx_bufsize = sizeof(jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size( driver->bitdepth );
global_packcache = packet_cache_new( driver->latency + 5, rx_bufsize, 1400 );

printf( "net_period: (up:%d/dn:%d)\n", driver->net_period_up, driver->net_period_down );
driver->pkt_buf = malloc(sizeof(jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size(driver->bitdepth));

int rx_bufsize = sizeof(jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size(driver->bitdepth);
global_packcache = packet_cache_new(driver->latency + 5, rx_bufsize, 1400);

jack_info("net_period: (up:%d/dn:%d)", driver->net_period_up, driver->net_period_down);
return (jack_driver_t *) driver;
}


/* DRIVER "PLUGIN" INTERFACE */

jack_driver_desc_t *
@@ -716,11 +694,9 @@ driver_initialize (jack_client_t *client, const JSList * params)
case 't':
handle_transport_sync = param->value.ui;
break;

}
}


return net_driver_new (client, "net_pcm", capture_ports,
playback_ports, sample_rate, period_size,
listen_port, handle_transport_sync,


+ 0
- 1
drivers/netjack/net_driver.h View File

@@ -72,5 +72,4 @@ struct _net_driver
unsigned int latency;
};


#endif /* __JACK_NET_DRIVER_H__ */

Write Preview
Loading…
Cancel
Save