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