modules/access/jack.c

   1 /*****************************************************************************
   2  * jack.c: JACK audio input module
   3  *****************************************************************************
   4  * Copyright (C) 2007-2008 the VideoLAN team
   5  * Copyright (C) 2007 Société des arts technologiques
   6  * Copyright (C) 2007 Savoir-faire Linux
   7  *
   8  * Authors: Arnaud Sala <arnaud.sala at savoirfairelinux.com>
   9  *          Julien Plissonneau Duquene <... at savoirfairelinux.com>
  10  *          Pierre-Luc Beaudoin <pierre-luc.beaudoin at savoirfairelinux.com>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /**
  28  * \file modules/access/jack.c
  29  * \brief JACK audio input functions
  30  */
  31
  32 /*****************************************************************************
  33  * Preamble
  34  *****************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 # include "config.h"
  38 #endif
  39
  40 #include <vlc_common.h>
  41 #include <vlc_plugin.h>
  42 #include <vlc_input.h>
  43 #include <vlc_demux.h>
  44 #include <vlc_url.h>
  45 #include <vlc_strings.h>
  46
  47 #include <jack/jack.h>
  48 #include <jack/ringbuffer.h>
  49
  50 #include <sys/types.h>
  51 #include <unistd.h>
  52
  53 /*****************************************************************************
  54  * Module descriptor
  55  *****************************************************************************/
  56 static int  Open ( vlc_object_t * );
  57 static void Close( vlc_object_t * );
  58
  59 #define PACE_TEXT N_( "Pace" )
  60 #define PACE_LONGTEXT N_( \
  61     "Read the audio stream at VLC pace rather than Jack pace." )
  62 #define AUTO_CONNECT_TEXT N_( "Auto Connection" )
  63 #define AUTO_CONNECT_LONGTEXT N_( \
  64     "Automatically connect VLC input ports to available output ports." )
  65
  66 vlc_module_begin ()
  67      set_description( N_("JACK audio input") )
  68      set_capability( "access_demux", 0 )
  69      set_shortname( N_( "JACK Input" ) )
  70      set_category( CAT_INPUT )
  71      set_subcategory( SUBCAT_INPUT_ACCESS )
  72
  73      add_bool( "jack-input-use-vlc-pace", false,
  74          PACE_TEXT, PACE_LONGTEXT, true )
  75      add_bool( "jack-input-auto-connect", false,
  76          AUTO_CONNECT_TEXT, AUTO_CONNECT_LONGTEXT, false )
  77
  78      add_shortcut( "jack" )
  79      set_callbacks( Open, Close )
  80 vlc_module_end ()
  81
  82 /*****************************************************************************
  83  * Local prototypes
  84  *****************************************************************************/
  85
  86 struct demux_sys_t
  87 {
  88     /* Audio properties */
  89     vlc_fourcc_t                i_acodec_raw;
  90     unsigned int                i_channels;
  91     int                         i_sample_rate;
  92     int                         i_audio_max_frame_size;
  93     int                         i_frequency;
  94     block_t                     *p_block_audio;
  95     es_out_id_t                 *p_es_audio;
  96     date_t                      pts;
  97
  98     /* Jack properties */
  99     jack_client_t               *p_jack_client;
 100     jack_port_t                 **pp_jack_port_input;
 101     jack_default_audio_sample_t **pp_jack_buffer;
 102     jack_ringbuffer_t           *p_jack_ringbuffer;
 103     jack_nframes_t              jack_buffer_size;
 104     jack_nframes_t              jack_sample_rate;
 105     size_t                      jack_sample_size;
 106     char                        *psz_ports;
 107     char                        **pp_jack_port_table;
 108     char                        i_match_ports;
 109 };
 110
 111 static int Demux( demux_t * );
 112 static int Control( demux_t *p_demux, int i_query, va_list args );
 113
 114 static void Parse ( demux_t * );
 115 static void Port_finder( demux_t * );
 116 static int Process( jack_nframes_t i_frames, void *p_arg );
 117
 118 static block_t *GrabJack( demux_t * );
 119
 120 /*****************************************************************************
 121  * Open: Connect to the JACK server
 122  *****************************************************************************/
 123 static int Open( vlc_object_t *p_this )
 124 {
 125     unsigned int i;
 126     demux_t             *p_demux = ( demux_t* )p_this;
 127     demux_sys_t         *p_sys;
 128     es_format_t         fmt;
 129     int i_out_ports = 0;
 130
 131     p_demux->pf_demux = Demux;
 132     p_demux->pf_control = Control;
 133
 134     /* Allocate structure */
 135     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 136     if( !p_sys )
 137         return VLC_ENOMEM;
 138
 139     /* Parse MRL */
 140     Parse( p_demux );
 141
 142     /* Create var */
 143     var_Create( p_demux, "jack-input-use-vlc-pace",
 144         VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 145     var_Create( p_demux, "jack-input-auto-connect",
 146         VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 147
 148     /* JACK connexions */
 149     /* define name and connect to jack server */
 150     char p_vlc_client_name[32];
 151     sprintf( p_vlc_client_name, "vlc-input-%d", getpid() );
 152     p_sys->p_jack_client = jack_client_open( p_vlc_client_name, JackNullOption, NULL );
 153     if( p_sys->p_jack_client == NULL )
 154     {
 155         msg_Err( p_demux, "failed to connect to JACK server" );
 156         free( p_sys );
 157         return VLC_EGENERIC;
 158     }
 159
 160     /* find some specifics ports if user entered a regexp */
 161     if( p_sys->psz_ports )
 162     {
 163         Port_finder( p_demux );
 164         if( p_sys->i_channels == 0 )
 165         {
 166             p_sys->i_channels = p_sys->i_match_ports;
 167         }
 168     }
 169
 170     /* allocate input ports */
 171     if( p_sys->i_channels == 0 ) p_sys->i_channels = 2 ; /* default number of port */
 172     p_sys->pp_jack_port_input = malloc(
 173         p_sys->i_channels * sizeof( jack_port_t* ) );
 174     if( p_sys->pp_jack_port_input == NULL )
 175     {
 176         jack_client_close( p_sys->p_jack_client );
 177         free( p_sys );
 178         return VLC_ENOMEM;
 179     }
 180
 181     /* allocate ringbuffer */
 182     /* The length of the ringbuffer is critical, it must be large enought
 183        to keep all data between 2 GrabJack() calls.  We assume 1 sec is ok */
 184     p_sys->p_jack_ringbuffer = jack_ringbuffer_create( p_sys->i_channels
 185          * jack_get_sample_rate( p_sys->p_jack_client )
 186          * sizeof( jack_default_audio_sample_t ) );
 187     if( p_sys->p_jack_ringbuffer == NULL )
 188     {
 189         free( p_sys->pp_jack_port_input );
 190         jack_client_close( p_sys->p_jack_client );
 191         free( p_sys );
 192         return VLC_ENOMEM;
 193     }
 194
 195     /* register input ports */
 196     for( i = 0; i <  p_sys->i_channels; i++ )
 197     {
 198         char p_input_name[32];
 199         snprintf( p_input_name, 32, "vlc_in_%d", i+1 );
 200         p_sys->pp_jack_port_input[i] = jack_port_register(
 201             p_sys->p_jack_client, p_input_name, JACK_DEFAULT_AUDIO_TYPE,
 202             JackPortIsInput, 0 );
 203         if( p_sys->pp_jack_port_input[i] == NULL )
 204         {
 205             msg_Err( p_demux, "failed to register a JACK port" );
 206             jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 207             free( p_sys->pp_jack_port_input );
 208             jack_client_close( p_sys->p_jack_client );
 209             free( p_sys );
 210             return VLC_EGENERIC;
 211         }
 212     }
 213
 214     /* allocate buffer for input ports */
 215     p_sys->pp_jack_buffer = malloc ( p_sys->i_channels
 216         * sizeof( jack_default_audio_sample_t * ) );
 217     if( p_sys->pp_jack_buffer == NULL )
 218     {
 219         for( i = 0; i < p_sys->i_channels; i++ )
 220             jack_port_unregister( p_sys->p_jack_client, p_sys->pp_jack_port_input[i] );
 221         jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 222         free( p_sys->pp_jack_port_input );
 223         jack_client_close( p_sys->p_jack_client );
 224         free( p_sys );
 225         return VLC_ENOMEM;
 226     }
 227
 228     /* set process callback */
 229     jack_set_process_callback( p_sys->p_jack_client, Process, p_demux );
 230
 231     /* tell jack server we are ready */
 232     if ( jack_activate( p_sys->p_jack_client ) )
 233     {
 234         msg_Err( p_demux, "failed to activate JACK client" );
 235         free( p_sys->pp_jack_buffer );
 236         for( i = 0; i < p_sys->i_channels; i++ )
 237             jack_port_unregister( p_sys->p_jack_client, p_sys->pp_jack_port_input[i] );
 238         jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 239         free( p_sys->pp_jack_port_input );
 240         jack_client_close( p_sys->p_jack_client );
 241         free( p_sys );
 242         return VLC_EGENERIC;
 243     }
 244
 245     /* connect vlc input to specifics jack output ports if requested */
 246    /*  if( var_GetBool( p_demux, "jack-input-auto-connect" ) && p_sys->psz_ports ) */
 247     if( p_sys->psz_ports )
 248     {
 249         int        i_input_ports;
 250         int        j;
 251
 252     if( p_sys->i_match_ports > 0 )
 253         {
 254             for( j = 0; j < p_sys->i_match_ports; j++ )
 255             {
 256                 i_input_ports = j % p_sys->i_channels;
 257                 jack_connect( p_sys->p_jack_client, p_sys->pp_jack_port_table[j],
 258                     jack_port_name( p_sys->pp_jack_port_input[i_input_ports] ) );
 259             }
 260         }
 261     }
 262
 263     /* connect vlc input to all jack output ports if requested */
 264     if( var_GetBool( p_demux, "jack-input-auto-connect" ) && !p_sys->psz_ports )
 265     {
 266         int        i_input_ports;
 267         int        j;
 268         const char **pp_jack_port_output;
 269
 270         pp_jack_port_output = jack_get_ports( p_sys->p_jack_client, NULL, NULL, JackPortIsOutput );
 271
 272         while( pp_jack_port_output && pp_jack_port_output[i_out_ports] )
 273         {
 274             i_out_ports++;
 275         }
 276         if( i_out_ports > 0 )
 277         {
 278             for( j = 0; j < i_out_ports; j++ )
 279             {
 280                 i_input_ports = j % p_sys->i_channels;
 281                 jack_connect( p_sys->p_jack_client, pp_jack_port_output[j],
 282                     jack_port_name( p_sys->pp_jack_port_input[i_input_ports] ) );
 283             }
 284         }
 285         free( pp_jack_port_output );
 286     }
 287
 288     /* info about jack server */
 289     /* get buffers size */
 290     p_sys->jack_buffer_size = jack_get_buffer_size( p_sys->p_jack_client );
 291     /* get sample rate */
 292     p_sys->jack_sample_rate = jack_get_sample_rate( p_sys->p_jack_client );
 293     /* get sample size */
 294     p_sys->jack_sample_size = sizeof( jack_default_audio_sample_t );
 295
 296     /* Define output format */
 297     es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_FL32 );
 298     fmt.audio.i_channels =  p_sys->i_channels;
 299     fmt.audio.i_rate =  p_sys->jack_sample_rate;
 300     fmt.audio.i_bitspersample =  p_sys->jack_sample_size * 8;
 301     fmt.audio.i_blockalign = fmt.audio.i_bitspersample / 8;
 302     fmt.i_bitrate = fmt.audio.i_rate * fmt.audio.i_bitspersample
 303         * fmt.audio.i_channels;
 304
 305     p_sys->p_es_audio = es_out_Add( p_demux->out, &fmt );
 306     date_Init( &p_sys->pts, fmt.audio.i_rate, 1 );
 307     date_Set( &p_sys->pts, 1 );
 308
 309     return VLC_SUCCESS;
 310 }
 311
 312
 313 /*****************************************************************************
 314  * Close: Disconnect from jack server and release associated resources
 315  *****************************************************************************/
 316 static void Close( vlc_object_t *p_this )
 317 {
 318     demux_t    *p_demux = ( demux_t* )p_this;
 319     demux_sys_t    *p_sys = p_demux->p_sys;
 320
 321     msg_Dbg( p_demux,"Module unloaded" );
 322     if( p_sys->p_block_audio ) block_Release( p_sys->p_block_audio );
 323     if( p_sys->p_jack_client ) jack_client_close( p_sys->p_jack_client );
 324     if( p_sys->p_jack_ringbuffer ) jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 325     free( p_sys->pp_jack_port_input );
 326     free( p_sys->pp_jack_buffer );
 327     free( p_sys->pp_jack_port_table );
 328     free( p_sys );
 329 }
 330
 331
 332 /*****************************************************************************
 333  * Control
 334  *****************************************************************************/
 335 static int Control( demux_t *p_demux, int i_query, va_list args )
 336 {
 337     bool  *pb;
 338     int64_t     *pi64;
 339     demux_sys_t *p_sys = p_demux->p_sys;
 340
 341     switch( i_query )
 342     {
 343     /* Special for access_demux */
 344     case DEMUX_CAN_PAUSE:
 345     case DEMUX_CAN_SEEK:
 346         pb = (bool *)va_arg( args, bool * );
 347         *pb = true;
 348         return VLC_SUCCESS;
 349
 350     case DEMUX_SET_PAUSE_STATE:
 351         return VLC_SUCCESS;
 352     case DEMUX_CAN_CONTROL_PACE:
 353         pb = ( bool* )va_arg( args, bool * );
 354         *pb = var_GetBool( p_demux, "jack-input-use-vlc-pace" );
 355         return VLC_SUCCESS;
 356
 357     case DEMUX_GET_PTS_DELAY:
 358         pi64 = ( int64_t* )va_arg( args, int64_t * );
 359         *pi64 = INT64_C(1000) * var_InheritInteger( p_demux, "live-caching" );
 360         return VLC_SUCCESS;
 361
 362     case DEMUX_GET_TIME:
 363         pi64 = ( int64_t* )va_arg( args, int64_t * );
 364         *pi64 =  date_Get(&p_sys->pts);
 365             return VLC_SUCCESS;
 366
 367     /* TODO implement others */
 368     default:
 369         return VLC_EGENERIC;
 370     }
 371
 372     return VLC_EGENERIC;
 373 }
 374
 375
 376 /*****************************************************************************
 377  * Demux
 378  *****************************************************************************/
 379 static int Demux( demux_t *p_demux )
 380 {
 381
 382     demux_sys_t *p_sys;
 383     es_out_id_t  *p_es;
 384     block_t *p_block;
 385
 386     p_sys = p_demux->p_sys;
 387     p_es = p_sys->p_es_audio;
 388     p_block = GrabJack( p_demux );
 389
 390     if( p_block )
 391     {
 392         es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts );
 393         es_out_Send( p_demux->out, p_es, p_block );
 394     }
 395
 396     return 1;
 397 }
 398
 399
 400 /*****************************************************************************
 401  * Process Callback : fill ringbuffer with Jack audio data
 402  *****************************************************************************/
 403 int Process( jack_nframes_t i_frames, void *p_arg )
 404 {
 405     demux_t            *p_demux = ( demux_t* )p_arg;
 406     demux_sys_t        *p_sys = p_demux->p_sys;
 407     unsigned int        i, j;
 408     size_t              i_write;
 409
 410     /* Get and interlace buffers */
 411     for ( i = 0; i < p_sys->i_channels ; i++ )
 412     {
 413         p_sys->pp_jack_buffer[i] = jack_port_get_buffer(
 414             p_sys->pp_jack_port_input[i], i_frames );
 415     }
 416
 417     /* fill ring buffer with signal */
 418     for( j = 0; j < i_frames; j++ )
 419     {
 420         for( i = 0; i <p_sys->i_channels; i++ )
 421         {
 422             if( jack_ringbuffer_write_space( p_sys->p_jack_ringbuffer ) <
 423                 p_sys->jack_sample_size ) {
 424                 msg_Err( p_demux, "buffer overflow");
 425                 return 0; // buffer overflow
 426             }
 427             i_write = jack_ringbuffer_write( p_sys->p_jack_ringbuffer,
 428                                              ( char * ) (p_sys->pp_jack_buffer[i]+j),
 429                                              p_sys->jack_sample_size );
 430             if (i_write != p_sys->jack_sample_size ) {
 431                 msg_Warn( p_demux, "error writing on ring buffer");
 432             }
 433         }
 434     }
 435
 436     return 0;
 437 }
 438
 439
 440 /*****************************************************************************
 441  * GrabJack: grab audio data in the Jack buffer
 442  *****************************************************************************/
 443 static block_t *GrabJack( demux_t *p_demux )
 444 {
 445     size_t      i_read;
 446     demux_sys_t *p_sys = p_demux->p_sys;
 447     block_t     *p_block;
 448
 449     /* read signal from ring buffer */
 450     i_read = jack_ringbuffer_read_space( p_sys->p_jack_ringbuffer );
 451
 452     if( i_read < 100 ) /* avoid small read */
 453     {   /* vlc has too much free time on its hands? */
 454 #undef msleep
 455 #warning Hmm.... looks wrong
 456         msleep(1000);
 457         return NULL;
 458     }
 459
 460     if( p_sys->p_block_audio )
 461     {
 462         p_block = p_sys->p_block_audio;
 463     }
 464     else
 465     {
 466         p_block = block_New( p_demux, i_read );
 467     }
 468     if( !p_block )
 469     {
 470         msg_Warn( p_demux, "cannot get block" );
 471         return 0;
 472     }
 473
 474     //Find the previous power of 2, this algo assumes size_t has the same size on all arch
 475     i_read >>= 1;
 476     i_read--;
 477     i_read |= i_read >> 1;
 478     i_read |= i_read >> 2;
 479     i_read |= i_read >> 4;
 480     i_read |= i_read >> 8;
 481     i_read |= i_read >> 16;
 482     i_read++;
 483
 484     i_read = jack_ringbuffer_read( p_sys->p_jack_ringbuffer, ( char * ) p_block->p_buffer, i_read );
 485
 486     p_block->i_dts = p_block->i_pts =    date_Increment( &p_sys->pts,
 487          i_read/(p_sys->i_channels * p_sys->jack_sample_size) );
 488
 489     p_sys->p_block_audio = p_block;
 490     p_block->i_buffer = i_read;
 491     p_sys->p_block_audio = 0;
 492
 493     return p_block;
 494 }
 495
 496
 497 /*****************************************************************************
 498  * Port_finder: compare ports with the regexp entered
 499  *****************************************************************************/
 500 static void Port_finder( demux_t *p_demux )
 501 {
 502
 503     demux_sys_t *p_sys = p_demux->p_sys;
 504     char *psz_expr = p_sys->psz_ports;
 505     char *token = NULL;
 506     char *state = NULL;
 507     char *psz_uri = NULL;
 508     const char **pp_jack_port_output = NULL;
 509     int i_out_ports = 0;
 510     int i_total_out_ports =0;
 511     p_sys->pp_jack_port_table = NULL;
 512
 513     /* parse the ports part of the MRL */
 514     for( token = strtok_r( psz_expr, ",", &state ); token;
 515             token = strtok_r( NULL, ",", &state ) )
 516     {
 517         psz_uri = decode_URI_duplicate( token );
 518         /* get the ports which match the regexp */
 519         pp_jack_port_output = jack_get_ports( p_sys->p_jack_client,
 520            psz_uri, NULL, JackPortIsOutput );
 521         if( pp_jack_port_output == NULL )
 522         {
 523             msg_Err( p_demux, "port(s) asked not found:%s", psz_uri );
 524             free( pp_jack_port_output );
 525         }
 526         else
 527         {
 528             while( pp_jack_port_output && pp_jack_port_output[i_out_ports] )
 529             {
 530                 i_out_ports++;
 531             }
 532             /* alloc an array to store all the matched ports */
 533             p_sys->pp_jack_port_table = xrealloc( p_sys->pp_jack_port_table,
 534                 (i_out_ports * sizeof( char * ) + i_total_out_ports * sizeof( char * ) ) );
 535
 536             for(int i=0; i<i_out_ports;i++)
 537             {
 538                 p_sys->pp_jack_port_table[i_total_out_ports+i] = ( char * ) pp_jack_port_output[i];
 539             }
 540
 541             i_total_out_ports += i_out_ports;
 542         }
 543     }
 544
 545     free( pp_jack_port_output );
 546     p_sys->i_match_ports = i_total_out_ports;
 547 }
 548
 549
 550 /*****************************************************************************
 551  * Parse: Parse the MRL
 552  *****************************************************************************/
 553 static void Parse( demux_t *p_demux )
 554 {
 555     demux_sys_t *p_sys = p_demux->p_sys;
 556     char *psz_dup = strdup( p_demux->psz_location );
 557     char *psz_parser = psz_dup;
 558
 559     if( !strncmp( psz_parser, "channels=", strlen( "channels=" ) ) )
 560     {
 561         p_sys->i_channels = abs( strtol( psz_parser + strlen( "channels=" ),
 562             &psz_parser, 0 ) );
 563     }
 564     else if( !strncmp( psz_parser, "ports=", strlen( "ports=" ) ) )
 565     {
 566         int i_len;
 567         psz_parser += strlen( "ports=" );
 568         if( strchr( psz_parser, ':' ) )
 569         {
 570             i_len = strchr( psz_parser, ':' ) - psz_parser;
 571         }
 572         else
 573         {
 574             i_len = strlen( psz_parser );
 575         }
 576         p_sys->psz_ports = strndup( psz_parser, i_len );
 577         psz_parser += i_len;
 578     }
 579     else
 580     {
 581         msg_Warn( p_demux, "unknown option" );
 582     }
 583
 584     while( *psz_parser && *psz_parser != ':' )
 585     {
 586         psz_parser++;
 587     }
 588
 589     if( *psz_parser == ':' )
 590     {
 591         for( ;; )
 592         {
 593             *psz_parser++ = '\0';
 594             if( !strncmp( psz_parser, "channels=", strlen( "channels=" ) ) )
 595             {
 596                 p_sys->i_channels = abs( strtol(
 597                     psz_parser + strlen( "channels=" ), &psz_parser, 0 ) );
 598             }
 599             else if( !strncmp( psz_parser, "ports=", strlen( "ports=" ) ) )
 600             {
 601                 int i_len;
 602                 psz_parser += strlen( "ports=" );
 603                 if( strchr( psz_parser, ':' ) )
 604                 {
 605                     i_len = strchr( psz_parser, ':' ) - psz_parser;
 606                 }
 607                 else
 608                 {
 609                     i_len = strlen( psz_parser );
 610                 }
 611                 p_sys->psz_ports = strndup( psz_parser, i_len );
 612                 psz_parser += i_len;
 613             }
 614             else
 615             {
 616                 msg_Warn( p_demux, "unknown option" );
 617             }
 618             while( *psz_parser && *psz_parser != ':' )
 619             {
 620                 psz_parser++;
 621             }
 622
 623             if( *psz_parser == '\0' )
 624             {
 625                 break;
 626             }
 627         }
 628     }
 629 }
 630