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