modules/access/jack.c

   1 /*****************************************************************************
   2  * jack.c: JACK audio input module
   3  *****************************************************************************
   4  * Copyright (C) 2007-2008 VLC authors and VideoLAN
   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 it
  13  * under the terms of the GNU Lesser General Public License as published by
  14  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software Foundation,
  24  * 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", 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 typedef struct
  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 } demux_sys_t;
 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     demux_t *p_demux = ( demux_t* )p_this;
 126     demux_sys_t *p_sys;
 127     es_format_t fmt;
 128     int i_out_ports = 0;
 129
 130     if (p_demux->out == NULL)
 131         return VLC_EGENERIC;
 132
 133     p_demux->pf_demux = Demux;
 134     p_demux->pf_control = Control;
 135
 136     /* Allocate structure */
 137     p_demux->p_sys = p_sys = vlc_obj_calloc( p_this, 1, sizeof( demux_sys_t ) );
 138     if( !p_sys )
 139         return VLC_ENOMEM;
 140
 141     /* Parse MRL */
 142     Parse( p_demux );
 143
 144     /* Create var */
 145     var_Create( p_demux, "jack-input-use-vlc-pace",
 146         VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 147     var_Create( p_demux, "jack-input-auto-connect",
 148         VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 149
 150     /* JACK connexions */
 151     /* define name and connect to jack server */
 152     char p_vlc_client_name[32];
 153     sprintf( p_vlc_client_name, "vlc-input-%d", getpid() );
 154     p_sys->p_jack_client = jack_client_open( p_vlc_client_name, JackNullOption, NULL );
 155     if( p_sys->p_jack_client == NULL )
 156     {
 157         msg_Err( p_demux, "failed to connect to JACK server" );
 158         return VLC_EGENERIC;
 159     }
 160
 161     /* find some specifics ports if user entered a regexp */
 162     if( p_sys->psz_ports )
 163     {
 164         Port_finder( p_demux );
 165         if( p_sys->i_channels == 0 )
 166         {
 167             p_sys->i_channels = p_sys->i_match_ports;
 168         }
 169     }
 170
 171     /* allocate input ports */
 172     if( p_sys->i_channels == 0 ) p_sys->i_channels = 2 ; /* default number of port */
 173     p_sys->pp_jack_port_input = malloc(
 174         p_sys->i_channels * sizeof( jack_port_t* ) );
 175     if( p_sys->pp_jack_port_input == NULL )
 176     {
 177         jack_client_close( p_sys->p_jack_client );
 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         return VLC_ENOMEM;
 192     }
 193
 194     /* register input ports */
 195     for( unsigned i = 0; i <  p_sys->i_channels; i++ )
 196     {
 197         char p_input_name[32];
 198         snprintf( p_input_name, 32, "vlc_in_%d", i+1 );
 199         p_sys->pp_jack_port_input[i] = jack_port_register(
 200             p_sys->p_jack_client, p_input_name, JACK_DEFAULT_AUDIO_TYPE,
 201             JackPortIsInput, 0 );
 202         if( p_sys->pp_jack_port_input[i] == NULL )
 203         {
 204             msg_Err( p_demux, "failed to register a JACK port" );
 205             jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 206             free( p_sys->pp_jack_port_input );
 207             jack_client_close( p_sys->p_jack_client );
 208             return VLC_EGENERIC;
 209         }
 210     }
 211
 212     /* allocate buffer for input ports */
 213     p_sys->pp_jack_buffer = malloc ( p_sys->i_channels
 214         * sizeof( jack_default_audio_sample_t * ) );
 215     if( p_sys->pp_jack_buffer == NULL )
 216     {
 217         for( unsigned i = 0; i < p_sys->i_channels; i++ )
 218             jack_port_unregister( p_sys->p_jack_client, p_sys->pp_jack_port_input[i] );
 219         jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 220         free( p_sys->pp_jack_port_input );
 221         jack_client_close( p_sys->p_jack_client );
 222         return VLC_ENOMEM;
 223     }
 224
 225     /* set process callback */
 226     jack_set_process_callback( p_sys->p_jack_client, Process, p_demux );
 227
 228     /* tell jack server we are ready */
 229     if ( jack_activate( p_sys->p_jack_client ) )
 230     {
 231         msg_Err( p_demux, "failed to activate JACK client" );
 232         free( p_sys->pp_jack_buffer );
 233         for( unsigned i = 0; i < p_sys->i_channels; i++ )
 234             jack_port_unregister( p_sys->p_jack_client, p_sys->pp_jack_port_input[i] );
 235         jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 236         free( p_sys->pp_jack_port_input );
 237         jack_client_close( p_sys->p_jack_client );
 238         return VLC_EGENERIC;
 239     }
 240
 241     /* connect vlc input to specifics jack output ports if requested */
 242    /*  if( var_GetBool( p_demux, "jack-input-auto-connect" ) && p_sys->psz_ports ) */
 243     if( p_sys->psz_ports )
 244     {
 245         for( int j = 0; j < p_sys->i_match_ports; j++ )
 246         {
 247             int i_input_ports = j % p_sys->i_channels;
 248             jack_connect( p_sys->p_jack_client, p_sys->pp_jack_port_table[j],
 249                 jack_port_name( p_sys->pp_jack_port_input[i_input_ports] ) );
 250         }
 251     }
 252
 253     /* connect vlc input to all jack output ports if requested */
 254     if( var_GetBool( p_demux, "jack-input-auto-connect" ) && !p_sys->psz_ports )
 255     {
 256         const char **pp_jack_port_output = jack_get_ports( p_sys->p_jack_client,
 257                                                            NULL, NULL, JackPortIsOutput );
 258
 259         while( pp_jack_port_output && pp_jack_port_output[i_out_ports] )
 260         {
 261             i_out_ports++;
 262         }
 263
 264         for( int j = 0; j < i_out_ports; j++ )
 265         {
 266             int i_input_ports = j % p_sys->i_channels;
 267             jack_connect( p_sys->p_jack_client, pp_jack_port_output[j],
 268                 jack_port_name( p_sys->pp_jack_port_input[i_input_ports] ) );
 269         }
 270
 271         free( pp_jack_port_output );
 272     }
 273
 274     /* info about jack server */
 275     /* get buffers size */
 276     p_sys->jack_buffer_size = jack_get_buffer_size( p_sys->p_jack_client );
 277     /* get sample rate */
 278     p_sys->jack_sample_rate = jack_get_sample_rate( p_sys->p_jack_client );
 279     /* get sample size */
 280     p_sys->jack_sample_size = sizeof( jack_default_audio_sample_t );
 281
 282     /* Define output format */
 283     es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_FL32 );
 284     fmt.audio.i_channels =  p_sys->i_channels;
 285     fmt.audio.i_rate =  p_sys->jack_sample_rate;
 286     fmt.audio.i_bitspersample =  p_sys->jack_sample_size * 8;
 287     fmt.audio.i_blockalign = fmt.audio.i_bitspersample / 8;
 288     fmt.i_bitrate = fmt.audio.i_rate * fmt.audio.i_bitspersample
 289         * fmt.audio.i_channels;
 290
 291     p_sys->p_es_audio = es_out_Add( p_demux->out, &fmt );
 292     date_Init( &p_sys->pts, fmt.audio.i_rate, 1 );
 293     date_Set( &p_sys->pts, VLC_TICK_0 );
 294
 295     return VLC_SUCCESS;
 296 }
 297
 298
 299 /*****************************************************************************
 300  * Close: Disconnect from jack server and release associated resources
 301  *****************************************************************************/
 302 static void Close( vlc_object_t *p_this )
 303 {
 304     demux_t    *p_demux = ( demux_t* )p_this;
 305     demux_sys_t    *p_sys = p_demux->p_sys;
 306
 307     msg_Dbg( p_demux,"Module unloaded" );
 308     if( p_sys->p_block_audio ) block_Release( p_sys->p_block_audio );
 309     if( p_sys->p_jack_client ) jack_client_close( p_sys->p_jack_client );
 310     if( p_sys->p_jack_ringbuffer ) jack_ringbuffer_free( p_sys->p_jack_ringbuffer );
 311     free( p_sys->pp_jack_port_input );
 312     free( p_sys->pp_jack_buffer );
 313     free( p_sys->pp_jack_port_table );
 314 }
 315
 316
 317 /*****************************************************************************
 318  * Control
 319  *****************************************************************************/
 320 static int Control( demux_t *p_demux, int i_query, va_list args )
 321 {
 322     bool *pb;
 323     demux_sys_t *p_sys = p_demux->p_sys;
 324
 325     switch( i_query )
 326     {
 327     /* Special for access_demux */
 328     case DEMUX_CAN_PAUSE:
 329     case DEMUX_CAN_SEEK:
 330         pb = va_arg( args, bool * );
 331         *pb = true;
 332         return VLC_SUCCESS;
 333
 334     case DEMUX_SET_PAUSE_STATE:
 335         return VLC_SUCCESS;
 336     case DEMUX_CAN_CONTROL_PACE:
 337         pb = va_arg( args, bool * );
 338         *pb = var_GetBool( p_demux, "jack-input-use-vlc-pace" );
 339         return VLC_SUCCESS;
 340
 341     case DEMUX_GET_PTS_DELAY:
 342         *va_arg( args, vlc_tick_t * ) =
 343             VLC_TICK_FROM_MS( var_InheritInteger( p_demux, "live-caching" ) );
 344         return VLC_SUCCESS;
 345
 346     case DEMUX_GET_TIME:
 347         *va_arg( args, vlc_tick_t * ) = date_Get(&p_sys->pts);
 348         return VLC_SUCCESS;
 349
 350     /* TODO implement others */
 351     default:
 352         return VLC_EGENERIC;
 353     }
 354
 355     return VLC_EGENERIC;
 356 }
 357
 358
 359 /*****************************************************************************
 360  * Demux
 361  *****************************************************************************/
 362 static int Demux( demux_t *p_demux )
 363 {
 364     demux_sys_t *p_sys;
 365     es_out_id_t *p_es;
 366     block_t *p_block;
 367
 368     p_sys = p_demux->p_sys;
 369     p_es = p_sys->p_es_audio;
 370     p_block = GrabJack( p_demux );
 371
 372     if( p_block )
 373     {
 374         es_out_SetPCR( p_demux->out, p_block->i_pts );
 375         es_out_Send( p_demux->out, p_es, p_block );
 376     }
 377
 378     return 1;
 379 }
 380
 381
 382 /*****************************************************************************
 383  * Process Callback : fill ringbuffer with Jack audio data
 384  *****************************************************************************/
 385 int Process( jack_nframes_t i_frames, void *p_arg )
 386 {
 387     demux_t *p_demux = ( demux_t* )p_arg;
 388     demux_sys_t *p_sys = p_demux->p_sys;
 389
 390     /* Get and interlace buffers */
 391     for ( unsigned i = 0; i < p_sys->i_channels ; i++ )
 392     {
 393         p_sys->pp_jack_buffer[i] = jack_port_get_buffer(
 394             p_sys->pp_jack_port_input[i], i_frames );
 395     }
 396
 397     /* fill ring buffer with signal */
 398     for( unsigned j = 0; j < i_frames; j++ )
 399     {
 400         for( unsigned i = 0; i <p_sys->i_channels; i++ )
 401         {
 402             if( jack_ringbuffer_write_space( p_sys->p_jack_ringbuffer ) <
 403                 p_sys->jack_sample_size ) {
 404                 msg_Err( p_demux, "buffer overflow");
 405                 return 0; // buffer overflow
 406             }
 407             size_t i_write = jack_ringbuffer_write( p_sys->p_jack_ringbuffer,
 408                                                     ( char * ) (p_sys->pp_jack_buffer[i]+j),
 409                                                     p_sys->jack_sample_size );
 410             if (i_write != p_sys->jack_sample_size ) {
 411                 msg_Warn( p_demux, "error writing on ring buffer");
 412             }
 413         }
 414     }
 415
 416     return 0;
 417 }
 418
 419
 420 /*****************************************************************************
 421  * GrabJack: grab audio data in the Jack buffer
 422  *****************************************************************************/
 423 static block_t *GrabJack( demux_t *p_demux )
 424 {
 425     demux_sys_t *p_sys = p_demux->p_sys;
 426     block_t *p_block;
 427
 428     /* read signal from ring buffer */
 429     size_t i_read = jack_ringbuffer_read_space( p_sys->p_jack_ringbuffer );
 430
 431     if( i_read < 100 ) /* avoid small read */
 432     {   /* vlc has too much free time on its hands? */
 433 #undef vlc_tick_sleep
 434 #warning Hmm.... looks wrong
 435         vlc_tick_sleep(1000);
 436         return NULL;
 437     }
 438
 439     if( p_sys->p_block_audio )
 440     {
 441         p_block = p_sys->p_block_audio;
 442     }
 443     else
 444     {
 445         p_block = block_Alloc( i_read );
 446     }
 447     if( !p_block )
 448     {
 449         msg_Warn( p_demux, "cannot get block" );
 450         return 0;
 451     }
 452
 453     //Find the previous power of 2, this algo assumes size_t has the same size on all arch
 454     i_read >>= 1;
 455     i_read--;
 456     i_read |= i_read >> 1;
 457     i_read |= i_read >> 2;
 458     i_read |= i_read >> 4;
 459     i_read |= i_read >> 8;
 460     i_read |= i_read >> 16;
 461     i_read++;
 462
 463     i_read = jack_ringbuffer_read( p_sys->p_jack_ringbuffer, ( char * ) p_block->p_buffer, i_read );
 464
 465     p_block->i_dts = p_block->i_pts = date_Increment( &p_sys->pts,
 466          i_read/(p_sys->i_channels * p_sys->jack_sample_size) );
 467
 468     p_sys->p_block_audio = p_block;
 469     p_block->i_buffer = i_read;
 470     p_sys->p_block_audio = 0;
 471
 472     return p_block;
 473 }
 474
 475
 476 /*****************************************************************************
 477  * Port_finder: compare ports with the regexp entered
 478  *****************************************************************************/
 479 static void Port_finder( demux_t *p_demux )
 480 {
 481     demux_sys_t *p_sys = p_demux->p_sys;
 482     char *psz_expr = p_sys->psz_ports;
 483     char *token = NULL;
 484     char *state = NULL;
 485     char *psz_uri = NULL;
 486     const char **pp_jack_port_output = NULL;
 487     int i_out_ports = 0;
 488     int i_total_out_ports =0;
 489     p_sys->pp_jack_port_table = NULL;
 490
 491     /* parse the ports part of the MRL */
 492     for( token = strtok_r( psz_expr, ",", &state ); token;
 493             token = strtok_r( NULL, ",", &state ) )
 494     {
 495         psz_uri = vlc_uri_decode_duplicate( token );
 496         /* get the ports which match the regexp */
 497         pp_jack_port_output = jack_get_ports( p_sys->p_jack_client,
 498            psz_uri, NULL, JackPortIsOutput );
 499         if( pp_jack_port_output == NULL )
 500             msg_Err( p_demux, "port(s) asked not found:%s", psz_uri );
 501         else
 502         {
 503             while( pp_jack_port_output[i_out_ports] )
 504                 i_out_ports++;
 505             /* alloc an array to store all the matched ports */
 506             p_sys->pp_jack_port_table = xrealloc( p_sys->pp_jack_port_table,
 507                 (i_out_ports * sizeof( char * ) + i_total_out_ports * sizeof( char * ) ) );
 508
 509             for(int i=0; i<i_out_ports;i++)
 510                 p_sys->pp_jack_port_table[i_total_out_ports+i] = ( char * ) pp_jack_port_output[i];
 511
 512             i_total_out_ports += i_out_ports;
 513
 514             free( pp_jack_port_output );
 515         }
 516     }
 517
 518     p_sys->i_match_ports = i_total_out_ports;
 519 }
 520
 521
 522 /*****************************************************************************
 523  * Parse: Parse the MRL
 524  *****************************************************************************/
 525 static void Parse( demux_t *p_demux )
 526 {
 527     demux_sys_t *p_sys = p_demux->p_sys;
 528     char *psz_dup = strdup( p_demux->psz_location );
 529     char *psz_parser = psz_dup;
 530
 531     if( !strncmp( psz_parser, "channels=", strlen( "channels=" ) ) )
 532     {
 533         p_sys->i_channels = abs( strtol( psz_parser + strlen( "channels=" ),
 534             &psz_parser, 0 ) );
 535     }
 536     else if( !strncmp( psz_parser, "ports=", strlen( "ports=" ) ) )
 537     {
 538         int i_len;
 539         psz_parser += strlen( "ports=" );
 540         if( strchr( psz_parser, ':' ) )
 541         {
 542             i_len = strchr( psz_parser, ':' ) - psz_parser;
 543         }
 544         else
 545         {
 546             i_len = strlen( psz_parser );
 547         }
 548         p_sys->psz_ports = strndup( psz_parser, i_len );
 549         psz_parser += i_len;
 550     }
 551     else
 552     {
 553         msg_Warn( p_demux, "unknown option" );
 554     }
 555
 556     while( *psz_parser && *psz_parser != ':' )
 557     {
 558         psz_parser++;
 559     }
 560
 561     if( *psz_parser == ':' )
 562     {
 563         for( ;; )
 564         {
 565             *psz_parser++ = '\0';
 566             if( !strncmp( psz_parser, "channels=", strlen( "channels=" ) ) )
 567             {
 568                 p_sys->i_channels = abs( strtol(
 569                     psz_parser + strlen( "channels=" ), &psz_parser, 0 ) );
 570             }
 571             else if( !strncmp( psz_parser, "ports=", strlen( "ports=" ) ) )
 572             {
 573                 int i_len;
 574                 psz_parser += strlen( "ports=" );
 575                 if( strchr( psz_parser, ':' ) )
 576                 {
 577                     i_len = strchr( psz_parser, ':' ) - psz_parser;
 578                 }
 579                 else
 580                 {
 581                     i_len = strlen( psz_parser );
 582                 }
 583                 p_sys->psz_ports = strndup( psz_parser, i_len );
 584                 psz_parser += i_len;
 585             }
 586             else
 587             {
 588                 msg_Warn( p_demux, "unknown option" );
 589             }
 590             while( *psz_parser && *psz_parser != ':' )
 591             {
 592                 psz_parser++;
 593             }
 594
 595             if( *psz_parser == '\0' )
 596             {
 597                 break;
 598             }
 599         }
 600     }
 601
 602     free( psz_dup );
 603 }
 604